Scanner#nextLine() leaves a leftover newline character

Question

I've been running into a problem with Scanner#nextLine. From my understanding, nextLine() should return the rest of the current input stream and then move on to the next line.

while (true){
      try{
        System.out.println("Please enter a month in numeric form");
        month = input.nextInt();
        System.out.println("Please enter a day in numeric form");
        day = input.nextInt();
        System.out.println("Please enter a two-digit year");
        if (input.hasNextInt() == true){
          year = input.next();
        }
        else{
          throw new java.util.InputMismatchException();
        }
        break;
      }
      catch(Exception e){
        System.err.println(e);
        System.out.println("\nOne of your inputs was not valid.");
        System.out.println(input.nextLine());
      }
    }

The problem is the last line. If I leave it as input.nextLine(), the next iteration of the loop accepts a newline character for the month. Why is that? Shouldn't the call to nextLine in the catch block consume the rest of the line (including the newline) and prompt the user correctly in the next iteration? Note: I've decided to print them to try and figure out what's happening, but no cigar.

I've gathered some output from the terminal to illustrate what I mean:

// What should happen (this is when catch contains input.next() rather than nextLine)
    /*
    Please enter a month in numeric form
    8
    Please enter a day in numeric form
    2
    Please enter a two-digit year
    badinput
    java.util.InputMismatchException

    One of your inputs was not valid.
    badinput
    Please enter a month in numeric form <------------- prompts for input, as expected
    */

// What happens when I have nextLine in the catch block (code above)
    /*
    Please enter a month in numeric form
    8
    Please enter a day in numeric form
    2
    Please enter a two-digit year
    badinput
    java.util.InputMismatchException

    One of your inputs was not valid.
                                         <------------ leftover newline printed, as expected
    Please enter a month in numeric form <---------------- does not prompt for input due to another leftover newline (why?)
    java.util.InputMismatchException

    One of your inputs was not valid.
    badinput <----------------------- prints badinput even though it should've been consumed on the last iteration (why?)
    Please enter a month in numeric form
    */

Before someone marks this as a duplicate, please understand that I've looked at the differences between next and nextLine on stackoverflow already. nextLine should consume the newline character but it doesn't seem to do that here. Thanks.

if (input.hasNextInt() == true){ is the same as if (input.hasNextInt()){. Why compare to true? — Andreas

Pshemo Pshemo · Accepted Answer · 2016-03-20T00:55:16

if (input.hasNextInt() == true) { // prefer `if(input.hasNextInt())`
    year = input.next();
} else {
    throw new java.util.InputMismatchException();
}

for input badinput will evaluate input.hasNextInt() as false which means that else block will be executed without consuming that badinput (to do it we need to call next() - not nextLine() because as you probably know if we use nextLine after nextInt we will consume remaining line separator, not value from next like, more info at Scanner is skipping nextLine() after using next(), nextInt() or other nextFoo() methods).

So since else block simply throws exception it moves control flow to catch section. This means we are skipping break so our loop will need to iterate once again.

Now in catch section you are simply printing

System.err.println(e);
System.out.println("\nOne of your inputs was not valid.");
System.out.println(input.nextLine());

which prints exception e, string "\nOne of your inputs was not valid." and result of nextLine() (which as explained before) will simply consume line separators which remained after last nextInt() call, so we still didn't consume badinput from Scanner.

This means that when loop starts another iteration and asks for month, it receives batinput which is not valid int so nextInt() throws InputMismatchException. And again we end up in catch block and we call nextLine() which this time consumes badinput.

Now since we finally consumed that incorrect value loop will start another iteration and we will be asked for value for month.

To avoid this kind of problems please read examples from: Validating input using java.util.Scanner. In first example you will find way to validate each input at time it is provided

Scanner sc = new Scanner(System.in);
int number;
do {
    System.out.println("Please enter a positive number!");
    while (!sc.hasNextInt()) {
        System.out.println("That's not a number!");
        sc.next(); // this is important!
    }
    number = sc.nextInt();
} while (number <= 0);
System.out.println("Thank you! Got " + number);

To avoid writing this code many times create your own utility method. You can even skip condition where you require from number to be positive like:

public static int getInt(Scanner sc, String askMsg) {
    System.out.println(askMsg);
    while (!sc.hasNextInt()) {
        System.out.println("That's not a number. Please try again");
        sc.next(); // consuming incorrect token
    }
    //here we know that next value is proper int so we can safely 
    //read and return it
    return sc.nextInt();
}

With this method your code could be reduced to

Scanner input = new Scanner(System.in);
int month = getInt(input, "Please enter a month in numeric form");
int day = getInt(input, "Please enter a day in numeric form");
int year = getInt(input, "Please enter a two-digit year");

You can add another version of that utility method in which you can let programmer add conditions which number should pass. We can use IntPredicate functional interface for that added in Java 8, which will allow us to create conditions using lambdas like

public static int getInt(Scanner sc, String askMsg, IntPredicate predicate) {
    System.out.println(askMsg);
    int number;
    boolean isIncorrect = true;
    do {
        while (!sc.hasNextInt()) {
            String value = sc.next(); // consuming incorrect token
            System.out.println(value + " is not valid number. Please try again");
        }
        number = sc.nextInt();
        if (!predicate.test(number)) {
            System.out.println(number + " is not valid number. Please try again");
        }else{
            isIncorrect=false;
        }
    } while (isIncorrect);

    return number;
}

Usage:

int year = getInt(input, "Please enter a two-digit year", i -> (i>=10 && i<=99));

Scanner#nextLine() leaves a leftover newline character

3 Answers