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. It’s commonly used to read 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() will read only the value “Hello”. The remaining word, “world”, will be 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”. Furthermore, the second call reads the value “world”.

Multiple whitespace 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, including a tab and new line, also gives the same result:

@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());
    }
}

Please note that 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 will behave with a custom delimiter.

For example, we’ll use the “:” character as our 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 used “:” to break the input into tokens instead of space.

3. nextLine() Method

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

In other words, we can use this method to read inputs that contain default delimiters, such as space. It stops reading just after receiving “\n” or hitting enter.

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.

An important point to note here is that as opposed to next(), defining a custom delimiter won’t change the nextLine() behaviour.

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 our custom delimiter and continues reading the input until it finds the “\n” character.

Next, we will present that other delimiter will be treated as a new line returning the same result:

Carriage Return (“\r”) and Carriage Return Line Feed (“\r\n”) are also treated as the new line delimiter 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());
    }
}

Similarly, with Carriage Return Line Feed:

@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());
    }
}

4. The Differences

In a nutshell, these are some key points to keep in mind when comparing 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. However, next() keeps the cursor in the same line

5. Other Ways to Tokenize a String

If you want to use the Scanner class as a tokenization mechanism, you can use some alternative ways like String.split(). There are some variations of the split method that you can use based on your needs.

There two split method with different parameters:

• split(String regex, int limit) – It will split the string based on the provided regular expression. The first argument is the regular expression and the second is the times the pattern it will be applied on the provided string
• split(String regex): It will split the string based on the provided regular expression. The pattern will be applied unlimited until it reaches the end of the string.

6. Conclusion

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