Clear the Scanner Buffer in Java

Last updated: June 7, 2024

Written by: Mohamed Helmy

Reviewed by: Michal Aibin

Java IO

Java Scanner

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Introduction

In Java, the Scanner class is commonly used to read input from various sources, including the console. However, Scanner can leave newline characters in the buffer, causing issues with subsequent input reads. Therefore, clearing the Scanner buffer ensures consistent and predictable input processing.

In this tutorial, we’ll dive into different Java methods for clearing the Scanner buffer.

2. Using nextLine() With hasNextLine() Methods

One straightforward buffer-clearing approach involves the nextLine() and hasNextLine() methods. Let’s take a simple example:

Scanner scanner = new Scanner("123\nHello World.");

@Test
public void givenInput_whenUsingNextLineWithHasNextLine_thenBufferCleared() {

    int number = scanner.nextInt();
    if (scanner.hasNextLine()) {
        scanner.nextLine();
    }
    String text = scanner.nextLine();

    assertEquals(123, number);
    assertEquals("Hello World", text);
}

Here, we simulate user input by creating a Scanner object with the string “123\nHello World”. Afterward, we use the scanner.nextInt() method to read an integer, which leaves the newline character in the buffer. We then check for any remaining input in the buffer with the scanner.hasNextLine() method and clear it by calling scanner.nextLine().

After clearing the buffer, we read a string input with the scanner.nextLine() method, which now correctly reads “Hello World”. Finally, we use assertEquals to verify that the integer read is 123 and the string read is “Hello World.”.

3. Using skip() Method

Another method to clear the buffer is using a scanner.skip(“\n”) method that skips over any newline character left in the buffer. Let’s see how it works with a simple implementation:

@Test
public void givenInput_whenUsingSkip_thenBufferCleared() {
    int number = scanner.nextInt();
    scanner.skip("\n");
    String text = scanner.nextLine();

    assertEquals(123, number);
    assertEquals("Hello World", text);
}

In this example, after reading the integer using the nextInt() method, we use the skip(“\n”) method to skip over the newline character left in the buffer. This clears the buffer, allowing the subsequent nextLine() method to correctly read “Hello World“.

4. Conclusion

In conclusion, managing the Scanner buffer is crucial for consistent and accurate input handling in Java applications. In this tutorial, we’ve explored clearing the Scanner buffer using nextLine() with hasNextLine().

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.