Scanner is skipping nextLine() after using next() or nextFoo()?

java

scanner

input-buffer

error-handling

byAlex Kataev·Sep 23, 2024

To resolve Java's Scanner issue where next() or nextFoo() are not digesting the newline (\n), drop in a scanner.nextLine() after these methods. This will chow down on the remaining newline, priming the next nextLine() to read the complete forthcoming user input successfully.

Scanner scanner = new Scanner(System.in);
int sheepCount = scanner.nextInt();            // Stops at newline
scanner.nextLine();                            // Devours the newline, nicknamed Mr. Sneaky
String dreamContent = scanner.nextLine();      // Gathers the next full line

The rule of thumb : consistently add nextLine() after next(), nextInt(), etc., to reorient Scanner for correct line inputs.

Exploring the next() and nextFoo() methods

In next() or nextFoo() encounters, Scanner whitewashes till it spots a delimiter (usually, it's the whitespace invader). However, as soon as it uncovers the token it needs, it hits a dead end, leaving the newline twiddling its thumbs in the input buffer.

To free ourselves from this issue, invariably attach a scanner.nextLine() after the type-specific nextFoo() methods:

int age = scanner.nextInt();          // Reads integer only, but—what's that? A leftover!
scanner.nextLine();                   // Time to clean out the pantry – consumes the remaining newline
String fullName = scanner.nextLine(); // Flawless execution!

We can also convert the captivated string into an integer for better error handling control:

String fullLine = scanner.nextLine(); // Takes in the entire line
int number;
try {
    number = Integer.parseInt(fullLine); // Here's where it morphs into a number
} catch (NumberFormatException e) {
    // If things go south, here's where we evaluate what went wrong
}

Decoding the underpinnings

`Scanner` input methods: A nutshell tour

nextInt() and like-minded methods are not just selfish, they refuse to die young—meaning, they stop reading right before reaching the newline.
Scanner.nextLine() picks up every single character, right up to and including the newline.
Blending nextInt() and nextLine() typically results in a not-so-tasty smoothie a.k.a unexpected behavior.

Newline characters: Same same but different

Windows prefers its line endings like most prefer their pizzas - with extra cheese, or \r\n.
UNIX/Linux keeps it simple with \n.
The older gen Macs (up to OS 9) roll with \r.

Yet, Scanner usually treats all these as the end of a line.

Clearing the buffer vs skipping characters

Opt for scanner.nextLine() to gobble up any freeloading newline characters.
For those pesky optional \r or avoiding line breaks, bring in scanner.skip("\\R?") to the rescue.

Straight to the point code snippets

Classy example leveraging skip patterns

scanner.nextInt();                 // Reads numerical value, dropping the mic at newline
scanner.skip("\\R?");              // Salsa dances across optional line break
String profoundThoughts = scanner.nextLine();   // The next line of user input is read flawlessly. Victory!

Error handling par excellence

String rawInput = scanner.nextLine(); // Wait! Don't jump conclusion. First, gather the data as a raw string

int rawInputToInteger;
try {
    rawInputToInteger = Integer.parseInt(rawInput); // Attempt conversion to an integer...
} catch (NumberFormatException e) {
    // ...but be prepared to catch 'em all, like a true Pokemon master!
}