Convert InputStream to Stream in Java

Last updated: May 12, 2024

Written by: Diego Martin

Reviewed by: Liam Williams

Java Streams

Java InputStream

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

When dealing with input data across different sources in Java, we sometimes encounter situations where we must handle data from an InputStream by converting it into a Stream<String>.

In this tutorial, we’ll look at different approaches to achieve this transformation.

2. Converting With BufferedReader and lines() Method

One effective way to convert an InputStream to a Stream<String> is by using a BufferedReader along with its lines() method.

First, we’ll define a byte array bytes containing a sequence of text lines:

byte[] bytes = "Hello\nWorld\nThis\nis\na\ntest".getBytes(StandardCharsets.UTF_8);
InputStream inputStream = new ByteArrayInputStream(bytes);

In the provided code block, we create a byte array named bytes to hold the UTF-8 encoded representation of the provided text lines. Then, we use the ByteArrayInputStream(bytes) to create an InputStream named inputStream from this byte array.

This setup allows us to simulate an InputStream containing the specified text, which will be used in subsequent examples for conversion into a Stream<String>.

Now, let’s see how we can implement this approach in a test scenario:

@Test
void givenInputStream_whenConvertingWithBufferedReader_thenConvertInputStreamToStringStream() throws IOException {
    try (InputStreamReader isr = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
      BufferedReader reader = new BufferedReader(isr)) {
        Stream<String> stringStream = reader.lines();

        String result = stringStream.reduce("", (s1, s2) -> s1 + s2);

        assertEquals("HelloWorldThisisatest", result);
    }
}

In the example above, we create a BufferedReader object wrapped around the InputStream using an InputStreamReader. This allows us to read lines of text efficiently from the InputStream. Additionally, the lines() method of the BufferedReader returns a Stream<String> containing the lines read from the input. Lastly, we process this Stream to concatenate all the String elements into a single result String using the reduce() operation, which we subsequently validate against the expected content using an assertion.

Note that we utilize try-with-resources to ensure that the InputStreamReader and BufferedReader are automatically closed at the end of the try block, releasing associated resources.

3. Converting with Scanner

Another approach involves using Scanner to tokenize the InputStream. Let’s look at a simple implementation:

@Test
void givenInputStream_whenConvertingWithScannerFindAll_thenConvertInputStreamToStringStream() {
    try (Scanner scanner = new Scanner(inputStream, StandardCharsets.UTF_8)) {
        Stream<String> stringStream = scanner.findAll(".+")
          .map(MatchResult::group);

        String result = stringStream.collect(Collectors.joining());

        assertEquals("HelloWorldThisisatest", result);
    }
}

In this approach, we initialize a Scanner object with the InputStream and configure it to use UTF-8 encoding using StandardCharsets.UTF_8.

Afterward, we employ the findAll() method with the regex pattern “.+” to match one or more characters, effectively capturing the content of the InputStream as a sequence of MatchResult.

Then, we map each match result to its matched group using the MatchResult::group, resulting in a Stream<String> containing the matched strings. Subsequently, we use the Collectors.joining() method to concatenate all the strings in the Stream into a single String named result.

4. Conclusion

In conclusion, converting an InputStream into a Stream<String> in Java is made possible using techniques like BufferedReader with its lines() method or leveraging the Scanner with its findAll() method. This allows for efficient processing of text-based data, providing flexibility and scalability when handling an InputStream in our Java applications.

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.