Java Scanner nextLine() After nextInt(): Why Input Is Skipped

You will learn how Java Scanner reads tokens and complete lines, why nextInt() leaves a newline behind, and two reliable ways to combine numeric and text input.

Scanner has methods that read input in different ways:

• nextInt() reads only an integer token, such as 3.
• next() reads one whitespace-separated token.
• nextLine() reads every remaining character on the current line, up to the line break.

When you type this and press Enter:

3↵

nextInt() consumes the 3, but it does not consume the line break created by pressing Enter. That line break remains waiting in the input stream.

The next nextLine() sees that it is already at the end of the current line. Therefore, it consumes the leftover line break and returns an empty string ("") immediately. It is not truly skipped; it successfully reads an empty remainder of the line.

This matters whenever a program mixes token-reading methods (nextInt, nextDouble, next) with line-reading (nextLine).

Imagine user input as text written on a roll of paper:

3\nfirst message\nsecond message\n

nextInt() uses scissors to cut out only the 3. The newline (\n) is still the next character on the paper.

Then nextLine() is asked to read until the next newline. But the very next character is already a newline, so it reads zero visible characters and returns an empty string.

Call nextLine() once to clear that leftover newline before asking for the actual text line.

Use an extra nextLine() after nextInt() to consume the rest of the number's line.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("Enter numerical value:");
        int option = input.nextInt();
        input.nextLine(); // Consume the leftover newline.

        System.out.println("Enter 1st string:");
        String string1 = input.nextLine();

        System.out.println("Enter 2nd string:");
        String string2 = input.nextLine();

        System.out.println("Option: " + option);
        System.out.println("First: " + string1);
        System.out.println("Second: " + string2);
    }
}

The extra input.nextLine() is not intended to collect the first string. Its job is to consume the remainder of the line containing the number.

Consider this program:

Scanner input = new Scanner(System.in);

System.out.print("Age: ");
int age = input.nextInt();

System.out.print("Name: ");
String name = input.nextLine();

Suppose the user types:

25↵

Execution proceeds as follows:

1. nextInt() reads 25 and stores it in age.
2. Pressing Enter added a newline character after 25.
3. That newline was not consumed by nextInt().
4. The program prints Name: .
5. nextLine() immediately finds the leftover newline.
6. nextLine() consumes it and returns "".
7. name becomes an empty string, so the program does not pause for a name.

Mixing numeric and text input is common in command-line programs:

• Registration form: read an age, then a full name and address.
• Menu program: read a numeric menu choice, then request a comment or search phrase.
• Inventory tool: read quantity and price, then read a product description.
• School application: read an ID number, then a student name and course title.
• Simple games: read a numeric difficulty level, then a player name.

In each case, account for the newline left by token-based methods before reading a full text line.

For small console programs, developers usually choose one of these patterns.

Pattern 1: Consume the newline after token input

int quantity = scanner.nextInt();
scanner.nextLine();
String description = scanner.nextLine();

Use this when nextInt() is convenient and you have validated that the user entered an integer.

Pattern 2: Read complete lines and parse them

String quantityText = scanner.nextLine();
int quantity = Integer.parseInt(quantityText.trim());
String description = scanner.nextLine();

This is often preferred for interactive input because each prompt corresponds to exactly one input line. It also makes validation easier:

System.out.print("Enter quantity: ");
String text = scanner.nextLine();

try {
    int quantity = Integer.parseInt(text.trim());
    System.out.println("Quantity: " + quantity);
}  (NumberFormatException exception) {
    System.out.println();
}

Expecting nextInt() to consume Enter

Broken assumption:

int option = input.nextInt();
String title = input.nextLine();

title becomes "" if the user pressed Enter after the number.

Fix it by consuming the newline:

int option = input.nextInt();
input.nextLine();
String title = input.nextLine();

Using next() when spaces should be allowed

String fullName = input.next();

If the user enters Ada Lovelace, this reads only Ada.

Use nextLine() for sentences, names with spaces, addresses, and descriptions:

// Token-based numeric input followed by line input
int number = scanner.nextInt();
scanner.nextLine();          // Clear the pending newline
String text = scanner.nextLine();

// Line-based input for everything
int number = Integer.parseInt(scanner.nextLine().trim());
String text = scanner.nextLine();

• nextInt() reads the number, not the Enter newline.
• next() reads one word/token, not a complete sentence.
• nextLine() can return "" when it starts at a line break.
• Use one clearing nextLine() after nextInt(), nextDouble(), or next() when reading the next full line.
• Use .trim() before parsing if surrounding spaces should be accepted.
• Validate user input before assuming it is a number.

Why does nextLine() skip after nextInt() in Java?

nextInt() leaves the newline from pressing Enter in the input stream. The following nextLine() consumes that newline and returns an empty string.

How do I fix Scanner nextLine() being skipped?

Call scanner.nextLine() once immediately after scanner.nextInt() to consume the leftover newline, then call nextLine() again to read the actual text.

Does the same problem happen with nextDouble() and next()?

Yes. These methods also read tokens rather than the complete line, so a later nextLine() may read the remaining line break.

Why is the first string empty instead of missing?

It is not missing. The first nextLine() successfully reads the empty remainder of the line after the number.

Should I use nextInt() or nextLine() for numbers?

For simple programs, either works. Reading with nextLine() and converting with is often easier when your program also reads text lines and needs validation.

• Java Scanner class — the input API that provides nextInt(), next(), and nextLine().
• Whitespace and newline characters — explains why pressing Enter produces input that methods may consume differently.
• String parsing — converts line input into values with methods such as Integer.parseInt().
• Exception handling — handles invalid numeric input using try/catch and NumberFormatException.
• Input validation — ensures console users provide valid values before the program continues.
• Java BufferedReader — another way to read console input, commonly used with line-based parsing.