Read Input Character-by-Character in Java

Last updated: January 15, 2024

Written by: Mohamed Helmy

Reviewed by: Michal Aibin

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 many Java applications, we need to read the input data character by character since it is a common task, especially when working with lots of data from a stream source.

In this tutorial, we’ll look at various ways to read one character at a time in Java.

2. Using BufferedReader for Console Input

We can utilize BufferedReader to perform reading character-by-character from the console. Note that this method is helpful if we seek to read characters interactively.

Let’s take an example:

@Test
public void givenInputFromConsole_whenUsingBufferedStream_thenReadCharByChar() throws IOException {
    ByteArrayInputStream inputStream = new ByteArrayInputStream("TestInput".getBytes());
    System.setIn(inputStream);

    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in))) {
        char[] result = new char[9];
        int index = 0;
        int c;
        while ((c = buffer.read()) != -1) {
            result[index++] = (char) c;
        }

        assertArrayEquals("TestInput".toCharArray(), result);
    }
}

Here, we simply simulate the console input by instantiating a ByteArrayInputStream with the “TestInput” content. Then, we read characters from System.in using BufferedReader. Afterward, we use the read() method to read one character as integer code and cast it into a char. Finally, we use the assertArrayEquals() method to verify that the read characters match the expected input.

3. Using FileReader for Reading from Files

When working on files, FileReader is an appropriate choice for reading character by character:

@Test
public void givenInputFromFile_whenUsingFileReader_thenReadCharByChar() throws IOException {
    File tempFile = File.createTempFile("tempTestFile", ".txt");
    FileWriter fileWriter = new FileWriter(tempFile);
    fileWriter.write("TestFileContent");
    fileWriter.close();

    try (FileReader fileReader = new FileReader(tempFile.getAbsolutePath())) {
        char[] result = new char[15];
        int index = 0;
        int charCode;
        while ((charCode = fileReader.read()) != -1) {
            result[index++] = (char) charCode;
        }

        assertArrayEquals("TestFileContent".toCharArray(), result);
    }
}

In the above code, we create a temporary test file with the content “tempTestFile” for simulation. Then, we use a FileReader to establish a connection to the file specified by its path using the tempFile.getAbsolutePath() method. Within a try-with-resources block, we read the file character by character.

4. Using Scanner for Tokenized Input

For a more dynamic approach that allows tokenized input, we can use Scanner:

@Test
public void givenInputFromConsole_whenUsingScanner_thenReadCharByChar() {
    ByteArrayInputStream inputStream = new ByteArrayInputStream("TestInput".getBytes());
    System.setIn(inputStream);

    try (Scanner scanner = new Scanner(System.in)) {
        if (scanner.hasNext()) {
            char[] result = scanner.next().toCharArray();
            assertArrayEquals("TestInput".toCharArray(), result);
        }
    }
}

We simulate the console input in the above test method by instantiating a ByteArrayInputStream with the “TestInput” content. Then, we utilize the hasNext() method to verify if there is another token. Afterward, we utilize the next() method to fetch the current one as a String.

5. Conclusion

In conclusion, we explored diverse methods in Java for reading characters, covering interactive console input using BufferedReader, file-based character reading with FileReader, and tokenized input handling via Scanner, offering developers versatile approaches to process character data efficiently in various scenarios.

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.