Integer.parseInt(scanner.nextLine()) and scanner.nextInt() in Java

1. Overview

In Java, we can use both Integer.parseInt(Scanner.nextLine()) and Scanner.nextInt() to read integers from a Scanner. However, there are some differences between these two methods.

In this tutorial, we’ll compare them and discuss their differences.

2. Reading Integers Using Integer.parseInt(scanner.nextLine()) and scanner.nextInt()

The Scanner.nextLine() method reads the whole line as a string from the scanner. So, if we want the result to be an Integer, we must convert the string into Integer by ourselves, for example, using the Integer.parseInt() method.

On the other hand, Scanner.nextInt() reads the next token of the input as an integer. A token in a Scanner is defined by the delimiter pattern used by the Scanner to parse the input stream. By default, the delimiter pattern for a Scanner is any whitespace character (such as a space, tab, or newline).

Now that we understand what these methods do. Let’s see how they read integers from a Scanner object. First, we’ll feed the scanner a string with a trailing linebreak:

String input = "42\n";

For simplicity, we’ll use unit test assertions to verify results in this tutorial.

First, let’s get the number 42 using the Scanner.nextLine() method:

Scanner sc1 = new Scanner(input);
int num1 = Integer.parseInt(sc1.nextLine());
assertEquals(42, num1);

Next, it’s Scanner.nextInt()‘s turn:

Scanner sc2 = new Scanner(input);
int num2 = sc2.nextInt();
assertEquals(42, num2);

As the two tests above show, both methods can read input from the Scanner object and get the integer 42 correctly.

Next, let’s look at the difference between these two approaches.

3. When the Input Is in an Invalid Number Format

Their first difference is when the input isn’t a valid number, the two approaches throw different exceptions.

Now, let’s change the input:

String input = "Nan\n";

When we read the input by scanner.nextLine() and try to convert the invalid input to an integer, it throws NumberFormatException:

Scanner sc1 = new Scanner(input);
assertThrows(NumberFormatException.class, () -> Integer.parseInt(sc1.nextLine()));

This is because sc1.nextLine() reads the next input line as a string. But, the later conversion fails. Therefore, NumberFormatException is thrown by the Integer.parseInt() method.

It’s worth mentioning that we’ve used the JUnit 5’s assertThrows() method for asserting the method call throws NumberFormatException.

On the other hand, when we attempt to read the input as an integer using Scanner.nextInt(), it raises InputMismatchException:

Scanner sc2 = new Scanner(input);
assertThrows(InputMismatchException.class, sc2::nextInt);

4. The Scanner.nextInt() Method Won’t Consume the Invalid Token

As mentioned earlier, Scanner.nextLine() reads the next line from the input as a string. Unlike the Scanner.nextLine() method, nextInt() will try to parse the next token in the input as an integer.

If it fails to parse a token, as we’ve seen earlier, nextInt() throws InputMismatchException. But we should note that Scanner.nextInt() doesn’t consume the parsing-failed token.

An example can help us to understand this quickly:

String input = "42 is a magic number\n";

// nextInt()
Scanner sc2 = new Scanner(input);
int num2 = sc2.nextInt();
assertEquals(42, num2);

// calling nextInt() again on "is" raises the exception
assertThrows(InputMismatchException.class, sc2::nextInt);

String theNextToken = sc2.next();
assertEquals("is", theNextToken);

As the example above shows, the input string has five tokens. The first one, “42“, is a valid integer. As we expected, the sc2.nextInt() call got the Integer 42. Then, we again called nextInt() and tried to parse the token “is” as an integer. It throws InputMismatchException, which is also our expectation.

Next, we called sc2.next() to get the next token as a string. We can see that the token “is“, which the nextInt() method failed to parse just now, gets read from the input. In other words, “is” isn’t consumed by the sc2.nextInt() method.

5. Linebreak Handling

Java Scanner default separates lines by the “\n” character in the input. So next, let’s look at how Scanner.nextLine() and nextInt() handle the new line character.

Let’s first prepare a multiple-line string as the input:

String input = new StringBuilder().append("42\n")
  .append("It is a magic number.\n")
  .toString();

The Scanner.nextLine() method consumes the entire line, including the line separator. However, it only returns the text without the newline character at the end, then sets the position to the beginning of the next line:

// nextLine()
Scanner sc1 = new Scanner(input);
int num1 = Integer.parseInt(sc1.nextLine());
String nextLineText1 = sc1.nextLine();
assertEquals(42, num1);
assertEquals("It is a magic number.", nextLineText1);

However, on the other hand, Scanner.nextInt() scans the next token of the input as an integer without consuming the newline character that follows it:

// nextInt()
Scanner sc2 = new Scanner(input);
int num2 = sc2.nextInt();
assertEquals(42, num2);

// nextInt() leaves the newline charater (\n) behind
String nextLineText2 = sc2.nextLine();
assertEquals("", nextLineText2);

In this test, after we got the number 42 by calling sc2.nextInt(), we called sc2.nextLine(). Then, as we can see, the method returns an empty string instead of “It is a magic number.“. This is because nextInt() doesn’t consume the newline character after ‘42‘.

6. Conclusion

In this article, we discussed the differences between Integer.parseInt(Scanner.nextLine()) and Scanner.nextInt() through examples. Let’s see a summary here:

• The two approaches throw different exceptions for inputs in an invalid number format.
• Scanner.nextLine() consumes the newline character in the Scanner but returns the string without it.
• Scanner.nextInt() doesn’t consume the newline character.
• Scanner.nextInt() doesn’t consume the token it fails to parse.