What’s the Difference between Scanner next() and nextLine() Methods?

1. Overview

The Scanner class comes with a set of methods that simplify the process of parsing inputs by breaking them into multiple tokens. In code, it commonly reads input data from different sources, such as consoles and files.

In this short tutorial, we’ll highlight the difference between its next() and nextLine() methods.

Even though these two methods may appear quite similar at first, they’re quite different.

2. next() Method

Typically, Scanner breaks the input into tokens using a delimiter pattern, which is, by default, any whitespace.

With that being said, next(), as the name implies, reads only the next token from the input until it encounters the delimiter.

2.1. Using the Default Delimiter

As mentioned earlier, the Scanner class uses whitespace as the default delimiter.

For instance, if we enter Hello world as the input, next() reads only the value Hello. The remaining word, world, is available for the next call of the next() method.

So, let’s exemplify the use of next() with a test case:

@Test
void givenInput_whenUsingNextMethod_thenReturnToken() {
    String input = "Hello world";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello", scanner.next());
        assertEquals("world", scanner.next());
    }
}

Here, Scanner uses the space character to parse the input.

Consequently, the first call of the next() method reads only the value Hello. On the other hand, the second call reads the value world.

Multiple whitespace characters are also treated as one single whitespace, and the result is the same:

@Test
void givenInput_whenUsingNextMethodWithMultipleWhiteSpaces_thenReturnToken() {
    String input = "Hello        world";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello", scanner.next());
        assertEquals("world", scanner.next());
    }
}

Multiple whitespace, like tabs and new lines, also result in the same output:

@Test
void givenInput_whenUsingNextMethodWithTabAndNewLine_thenReturnToken() {
    String input = "Hello    \t\n world";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello", scanner.next());
        assertEquals("world", scanner.next());
    }
}

Notably, the whitespace includes several characters, not only space, such as tab (\t), return line (\n), and more characters.

2.2. Using a Custom Delimiter

The Scanner class provides a convenient way to override the default delimiter through the useDelimiter() method.

So, let’s see how the next() method behaves with a custom delimiter.

For example, we can use the : colon character as the delimiter:

@Test
void givenInput_whenUsingNextMethodWithCustomDelimiter_thenReturnToken() {
    String input = "Hello :world";
    try (Scanner scanner = new Scanner(input)) {
        scanner.useDelimiter(":");

        assertEquals("Hello ", scanner.next());
        assertEquals("world", scanner.next());
    }
}

As shown above, next() reads Hello, followed by the space character this time. The reason is that Scanner uses : to break the input into tokens instead of a space.

3. nextLine() Method

On the other hand, nextLine() consumes the whole line of the input, including whitespace characters, until it reaches the \n newline character.

In other words, we can use this method to read inputs that contain default delimiters, such as a space. It stops reading just after receiving \n (such as when hitting Return).

So, let’s see it in practice:

@Test
void givenInput_whenUsingNextLineMethod_thenReturnEntireLine() {
    String input = "Hello world\nWelcome to baeldung.com";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello world", scanner.nextLine());
        assertEquals("Welcome to baeldung.com", scanner.nextLine());
    }
}

As we can see, the first scanner.nextLine() reads the entire value Hello world, and the second one consumes the rest of the input.

Unlike next(), which places the cursor in the same line, nextLine() points the cursor to the next line after reading the input.

Importantly, unlike next(), defining a custom delimiter won’t change the behavior of nextLine().

Let’s confirm this using a test case:

@Test
void givenInput_whenUsingNextLineWithCustomDelimiter_thenIgnoreDelimiter() {
    String input = "Hello:world\nWelcome:to baeldung.com";
    try (Scanner scanner = new Scanner(input)) {
        scanner.useDelimiter(":");

        assertEquals("Hello:world", scanner.nextLine());
        assertEquals("Welcome:to baeldung.com", scanner.nextLine());
    }
}

Unsurprisingly, the nextLine() method ignores the custom delimiter and continues reading the input until it finds the \n character.

Carriage Return (\r) and Carriage Return Line Feed (\r\n) are also treated as new line delimiters by nextLine():

@Test
void givenInput_whenUsingNextLineMethodWithCR_thenReturnEntireLine() {
    String input = "Hello world\rWelcome to baeldung.com";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello world", scanner.nextLine());
        assertEquals("Welcome to baeldung.com", scanner.nextLine());
    }
}

Both function the same way:

@Test
void givenInput_whenUsingNextLineMethodWithCRLF_thenReturnEntireLine() {
    String input = "Hello world\r\nWelcome to baeldung.com";
    try (Scanner scanner = new Scanner(input)) {
        assertEquals("Hello world", scanner.nextLine());
        assertEquals("Welcome to baeldung.com", scanner.nextLine());
    }
}

Thus, we can be sure that the nextLine() method works similarly on different platforms and

In a nutshell, let’s understand the key points to keep in mind when comparing the next() and nextLine() methods:

• nextLine() returns the entire text up to the return line, next() reads a tokenized text based on a given delimiter (whitespace by default)
• nextLine() places the scanner position on the next line after reading the input, next() keeps the cursor in the same line

This way, both serve a purpose, but one is more specific.

4. Other Ways to Tokenize a String

Alternatively, we can use tokenization methods like String.split(). In particular, several variations of the split can be used depending on the requirements.

There are two main split methods with different parameters:

• split(String regex, int limit): splits the string based on the provided regular expression (first argument), while ensuring that a limit (second argument) is placed on the number of times it’s applied
• split(String regex): splits the string based on the provided regular expression (first argument) an unlimited number of times

Care should be taken with the latter, as we might get unexpected results.

5. Key Differences

Let’s summarize the key differences when comparing the next() and nextLine() methods in Scanner:

Thus, we should be able to pick between these two options easily.

6. Conclusion

In this article, we explained in detail the difference between Scanner.next() and Scanner.nextLine() methods.

In detail, we understood that both serve a similar purpose, but they are useful in different situations. This way, they are a readable way to consume data.