Almost every java learner encounters this problem at some point.
You write a simple program that asks for an age (an int) and then a name (a String). You run it, type an age, press Enter, and before you've typed a single letter of the name, the program has already finished running.
It feels like a glitch.
But, in reality, you have encountered what developers call the Scanner buffer issue. To keep things simple for us beginners, I like to call it the nextLine() issue.
Problem
Code That “Should” Work
Take a look at this snippet.
Scanner sc = new Scanner(System.in);
System.out.println("Enter an age");
int age = sc.nextInt();
// Example input: 25
System.out.println("Enter a name");
String name = sc.nextLine();
// Example input: Ahi
System.out.println("Name: " + name);
System.out.println("Age: " + age);
You might expect the following interaction:
Enter an age
25
Enter a name
Ahi
Sadly, it is not that simple.
When you type 25 and press Enter. The program finishes before you can even type the name. Therefore, the actual output is:
Name:
Age: 25
Why did this happen? Let’s investigate.
Important note:
I’ve included a quick glossary at the bottom to help you with unfamiliar terms.
Investigation
What Happens Inside?
When you use Scanner class to read input from the keyboard, every key you press is first stored inside the input buffer as a character.
The characters remain in the buffer until:
The program consumes them (that is, takes them out of the buffer) using methods like
next(),nextInt(),nextLine(), orThe program terminates.
The Scanner class reads input using two strategies:
Token-based parsing
Line-based parsing
Every character inside the buffer is examined one by one.
Depending on the parsing rules being applied, a character will either be:
Consumed and returned (removed from the buffer and included in the result)
Consumed and discarded (removed from the buffer but not returned as part of the result)
Left in the buffer (to be processed later)
Token-Based Parsing
In this approach, input is divided into tokens and one token is returned at a time.
Rules:
Leading delimiters are consumed and discarded.
From the first non-delimiter character, characters are consumed until a delimiter is detected.
The detected delimiter is left in the buffer.
The consumed characters are returned to the program as one token.
Methods that use this approach:
next()nextInt()nextDouble()nextFloat()nextLong()nextBoolean()
Line-Based Parsing
In this approach, input is read as an entire line.
Rules:
Characters are consumed continuously, including whitespace characters (spaces and tabs).
Reading continues until a line terminator (
'\n') is encountered.The line terminator (
'\n') is consumed and discarded.All characters before the line terminator are returned as a single
String.
Method that uses this approach:
-
nextLine()
Observation
Understanding the Behaviour
Now that we understand how input is read, let us trace the execution of our “failing” code to identify where things went wrong.
Step 1: Input Entry
When the program runs, the terminal displays:
Enter an age
You type 25 and press Enter.
Buffer Status:
['2'] ['5'] ['\n']
Step 2: nextInt() Executes
int age = sc.nextInt();
Following the rules of token-based parsing, nextInt():
Begins reading from the buffer
Consumes
'2'and'5'(non-delimiter characters)Encounters
'\n', which is a delimiterStops reading but does not consume the delimiter
Parses the token
"25"into the integer value25Returns
25to the program
int age = 25;
Buffer Status:
['\n']
The line feed remains in the buffer.
Step 3: Prompt Appears
The terminal now shows:
Enter an age
25
Enter a name
Misconception: You might expect the program to pause here and wait for you to type Ahi.
Reality: The program pauses only if the buffer is empty.
Step 4: nextLine() Executes
String name = sc.nextLine();
Following the rules of line-based parsing, nextLine():
Checks the buffer
Immediately detects
'\n'Consumes and discards the line feed
Returns everything before
'\n'
There were no characters before it.
Therefore, it returns an empty string.
String name = "";
Step 5: Final Output
The program executes:
System.out.println("Name: " + name);
System.out.println("Age: " + age);
The output is:
Name:
Age: 25
Solution
Now you understand where the problem occurred and why. Let us fix it.
There are several ways to solve this; we will discuss a few.
1. The Quick Fix
The most straightforward solution is to consume the leftover line feed.
Add an extra nextLine() immediately after nextInt() to clear the buffer.
System.out.println("Enter an age");
int age = sc.nextInt();
sc.nextLine(); // Consumes and discards the leftover '\n'
System.out.println("Enter a name");
String name = sc.nextLine();
Why it Works:
nextInt()leaves the line feed character ('\n') in the input buffer.The additional
nextLine()consumes that'\n'and removes it.Now, when the second
nextLine()executes, the buffer is clean, so the program waits for your name input.
2. The Professional Approach
Avoid mixing token-based and line-based parsing.
Instead, read all input using nextLine() and convert numeric values explicitly using parsing methods such as Integer.parseInt(). This method takes a numeric string (for example, "25") and converts it into a primitive int value (25).
System.out.println("Enter an age:");
int age = Integer.parseInt(sc.nextLine());
System.out.println("Enter a name:");
String name = sc.nextLine();
Why it Works:
nextLine()consumes the line feed character each time it reads input, so no delimiters remain in the buffer.Parsing explicitly using methods such as
Integer.parseInt()gives you greater control over input handling.
Worth knowing:
if the input isn't a valid number, Integer.parseInt() throws a NumberFormatException. In a real application, you would typically validate the input before parsing it.
Other Parsing Methods:
The same pattern applies to other numeric types:
Double.parseDouble()Float.parseFloat()Long.parseLong()Boolean.parseBoolean()
3. The Duct Tape Fix
You can reverse the order of the inputs and avoid the issue.
If you read the String first and the int afterwards, the problem seems as though it never occurred.
System.out.println("Enter a name");
String name = sc.nextLine();
System.out.println("Enter an age");
int age = sc.nextInt();
Why This is Wrong:
nextInt() still leaves '\n' in the input buffer.
If the program later requires another call to nextLine(), the same issue will immediately reappear.
Conclusion
Now you understand the whys, the hows, the dos and the don’ts.
In Java, nothing is broken. The behaviour is defined, the rules are strict, and the machine is consistent. Use that consistency to your advantage rather than fighting against it.
Try the following example yourself:
Scanner sc = new Scanner(System.in);
System.out.println("Enter your full name:");
String firstName = sc.next();
String lastName = sc.next();
System.out.println("Hello " + firstName + " " + lastName);
Enter your own name, for example:
Aditya Sinha
The output will be:
Hello Aditya Sinha
Pause and think.
Why does this work?
How does
next()decide where to stop reading?What remains in the input buffer afterwards?
What happens if the name has more than two parts?
Glossary
Short and Simple
Buffer
When data is being transferred from a source (Point A) to a destination (Point B), it is temporarily stored in a small memory area between them called a buffer. It serves as a waiting room for data and typically follows the FIFO (First In, First Out) principle.
Input Buffer:
Source: Keyboard
Destination: Java program
However, internally, the data passes through multiple layers before reaching the Java program.
Token
A token is a continuous sequence of non-delimiter characters.
Token formation is the internal act of grouping characters together until a delimiter is found.
Input buffer:
['2']['5'][' ']['A']['h']['i']
Tokens formed:
"25"
"Ahi"
Parsing
Theoretical view.
When you type 25 through the keyboard, the computer receives (represented internally in binary form):
'2' -> ASCII value 50
'5' -> ASCII value 53
'\n' -> ASCII value 10
At this stage, the computer does not recognise the integer 25.
It only sees the sequence of characters '2', '5', and '\n'.
Inside a nextInt() method of the Scanner class:
Token Formation occurs:
['2','5','\n'] -> "25"
A String token "25" is formed.
At this point, it is still text, not a numeric value.
The Actual Parsing:
Parsing now occurs inside nextInt().
The String "25" is:
Checked to ensure it is a valid integer
Converted into the numeric value
25
"25" -> before parsing (String)
25 -> after parsing (int)
The integer value is then returned to the program.
Parsing here simply means converting characters into a meaningful data type.
This is different from compiler parsing, which involves analysing the grammatical structure of an entire program.
In both cases, however, the core idea remains the same: Interpreting input according to defined rules.
Whitespace Character
A whitespace character has no visible symbol. It appears as blank space and is used to create horizontal or vertical separation between visible characters.
A few examples:
' '(space)'\t'(tab)'\n'(line feed)
Use:
System.out.println("Name" + " " + "Age" + "\n" + "Ahi" + "\t" + "25");
Output:
Name Age
Ahi 25
Escape Sequence Character
An escape sequence is a special character representation used inside a string. It always starts with a backslash (\), which acts as a signal to the compiler to "escape" its normal rules of treating a character.
These characters cannot be typed directly inside a string because it has special meaning in Java.
For example, double quotes " are used to mark the beginning and end of a string.
If you try to use them directly inside a string, the compiler gets confused.
A few escape sequence characters:
\n(Line Feed)\t(Tab)\"(Double Quote)
If you want to print text inside double quotes, you have to use escape sequence.
System.out.println("He said, \"Hello!\"");
Without \", Java would think the string ends before Hello!, causing a compilation error.
Output:
He said, "Hello!"
Escape sequences and whitespace characters are not the same thing.
While whitespace is any character that creates a blank space, escape sequence characters are not always blank spaces.
\"
Escape sequence
Not whitespace\n
Escape sequence
Also whitespace' '(space)
Whitespace
Not an escape sequence
Delimiter
In the context of Scanner and input processing in Java, a delimiter is a character or pattern used to separate input into smaller pieces called tokens. It marks where one token ends and the next begins like a boundary.
By default, Scanner uses whitespace characters as delimiters.
When you type:
25 Ahi
The space acts as a delimiter, and Scanner sees two tokens:
[25] [Ahi]
You can even change it using useDelimiter() method:
sc.useDelimiter(",");
Now the comma becomes the delimiter.
If the input is:
25,Ahi
The tokens will be:
[25] [Ahi]
Line terminator
A line terminator is a kind of whitespace characters (also an escape sequence character) that is used to move the cursor to a new line.
Few examples:
‘\n’(Line feed)'\r'(Carriage return)
System.out.println("Hello\nWorld");
Output:
Hello
World
Note
Everything above is a great mental model for understanding why this bug happens, but it's still a simplified picture. Under the hood, Scanner doesn't actually go character by character. It uses regex pattern matching to find tokens in the buffer. If you're curious to see the real thing, here's where to look:
Scannerclass, Java SE Documentation: the official reference for hownextInt(),nextLine(), and delimiters really work.OpenJDK source for
Scanner.java: the actual tokenizing code, if you want to trace it yourself.
Let's Connect!
If you found this helpful, or have any doubts or queries, feel free to reach out via the links below:
Top comments (0)