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 we 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”.
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 nexLine() behavior.
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.
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. Conclusion
In this article, we explained in detail the difference between Scanner.next() and Scanner.nextLine() methods.
As always, the complete source code for the examples is available over on GitHub.
res – REST with Spring (eBook) (everywhere)
