How to Convert an InputStream into a String in Java

When working with Java, it’s common to encounter situations where you need to convert an InputStream into a String. Whether you’re reading data from a file, network socket, or other sources, understanding how to efficiently perform this conversion is crucial.

Why Convert an InputStream to a String?

An InputStream is a stream of bytes that you can read from. However, when working with text data, you often need to convert these bytes into a String. For example, you might want to:

• Log the content of a stream.
• Process text data from a file.
• Pass text data between different parts of an application.

Basic Approach: Using BufferedReader and StringBuilder

One of the most straightforward ways to convert an InputStream to a String is by using BufferedReader and StringBuilder. This method reads the stream line by line and appends each line to a StringBuilder.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class InputStreamConverter {

    public static String convertStreamToString(InputStream inputStream) throws IOException {
        StringBuilder stringBuilder = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
            String line;
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line).append(System.lineSeparator());
            }
        }
        return stringBuilder.toString();
    }
}

Output:
Suppose your InputStream contains the following data:

Hello
World

The above code will produce:

Hello
World

Using Scanner for Simple Stream Reading

Another simple approach is to use a Scanner to read the entire stream into a String. This method is concise and easy to implement.

import java.io.InputStream;
import java.util.Scanner;

public class InputStreamToString {

    public static String convertStreamToString(InputStream inputStream) {
        try (Scanner scanner = new Scanner(inputStream).useDelimiter("\\A")) {
            return scanner.hasNext() ? scanner.next() : "";
        }
    }
}

Output:
If the InputStream contains:

Java InputStream Example

The output will be:

Java InputStream Example

Java 9+ Approach: Using readAllBytes

For those using Java 9 or later, the InputStream class has introduced a readAllBytes method, which provides a direct way to read all bytes from the stream and convert them to a String.

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

public class StreamConverter {

    public static String convertStreamToString(InputStream inputStream) throws IOException {
        return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
    }
}

Output:
Given an InputStream containing:

Efficient Stream Handling

The result will be:

Efficient Stream Handling

Handling Large Streams: Using ByteArrayOutputStream

When dealing with larger streams, you might want to read the stream in chunks and accumulate the result. Here’s an approach using ByteArrayOutputStream.

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class StreamToStringConverter {

    public static String convertStreamToString(InputStream inputStream) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        while ((length = inputStream.read(buffer)) != -1) {
            byteArrayOutputStream.write(buffer, 0, length);
        }
        return byteArrayOutputStream.toString("UTF-8");
    }
}

Output:
For an InputStream containing a large text block:

This is a large text block...

The output will match the input content.

Converting an InputStream to a String is a common requirement in Java. The method you choose can depend on factors like the size of the data, performance needs, and the Java version you’re using. Whether you opt for the simplicity of BufferedReader, the modern approach with readAllBytes, or another method, knowing your options will help you make the right choice for your specific scenario.