How To Convert an InputStream Into a String in Java

In Java, an InputStream is an abstract class in the java.io package that provides a way to read data sequentially as a stream of bytes. It is a foundation for various input stream implementations, allowing data to be read from sources such as files, network connections, and memory buffers.

• public abstract class InputStream implements Closeable

Common Implementations of InputStream:

• FileInputStream – Use to read data from a file.
• ByteArrayInputStream – Used to read data from a byte array.
• BufferedInputStream – Buffers data for efficient reading.
• BufferedInputStream – Buffers data for efficient reading.
• ObjectInputStream – Reads Java objects from a stream.
• DataInputStream – Reads primitive data types from a stream.
• InputStreamReader – Converts bytes to characters (wrapper for InputStream).

Converting InputStream to String: An InputStream can be converted to a String in Java using various approaches. Some of them are explained below:

1. Using InputStreamReader and BufferedReader: With this method, the user can read the stream line by line and append it to a StringBuilder.
   

   import java.io.*;
   
   public class InputStreamToString {
    public static String convert(InputStream iStream) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(iStream));
             StringBuilder stringBuilder = new StringBuilder()) {
            String line;
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line).append("\n");
            }
            return stringBuilder.toString();
        }
    }
   
   
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new ByteArrayInputStream("Hello, world!".getBytes());
        System.out.println(convert(inputStream));
    }
   }    

2. Using Scanner: The Scanner class can read the entire stream in one go.
   

   import java.io.*;
   import java.util.Scanner;

   
   public class InputStreamToString {
    public static String convert(InputStream iStream) {
        try (Scanner scanner = new Scanner(iStream).useDelimiter("\\A")) {
            return scanner.hasNext() ? scanner.next() : "";
        }
    }
    public static void main(String[] args) {
        InputStream inputStream = new ByteArrayInputStream("Hello, world!".getBytes());
        System.out.println(convert(inputStream));
    }
   }

3. Using Stream API (Java 8+): Stream API can be used for Java 8 or later versions.
   

   import java.io.*;
   import java.nio.charset.StandardCharsets;
   import java.util.stream.Collectors;
   
   public class InputStreamToString {
    public static String convert(InputStream iStream) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(iStream, StandardCharsets.UTF_8))) {
            return reader.lines().collect(Collectors.joining("\n"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
   
    public static void main(String[] args) {
        InputStream inputStream = new ByteArrayInputStream("Hello, world!".getBytes(StandardCharsets.UTF_8));
        System.out.println(convert(inputStream));
    }
   }

4. Using IOUtils from Apache Commons IO: If you have Apache Commons IO as a dependency, you can use IOUtils.toString().
   

   import org.apache.commons.io.IOUtils;
   import java.io.*;
   import java.nio.charset.StandardCharsets;
   
   public class InputStreamToString {
    public static String convert(InputStream iStream) throws IOException {
        return IOUtils.toString(iStream, StandardCharsets.UTF_8);
    }
   
   
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new ByteArrayInputStream("Hello, world!".getBytes(StandardCharsets.UTF_8));
        System.out.println(convert(inputStream));
    }
   }
   Maven Dependency for Apache Commons IO:
   <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.11.0</version>
   </dependency>
   
   

5. Using ByteArrayOutputStream: This reads the input stream into a ByteArrayOutputStream and converts it to a string.
   

   import java.io.*;
   
   public class InputStreamToString {
   	public static String convert(InputStream iStream) throws IOException {
       	ByteArrayOutputStream result = new ByteArrayOutputStream();
       	byte[] buffer = new byte[1024];
       	int length;
       	while ((length = iStream.read(buffer)) != -1) {
           	result.write(buffer, 0, length);
       	}
       	return result.toString("UTF-8");
   	}
   
   	public static void main(String[] args) throws IOException {
       	InputStream inputStream = new ByteArrayInputStream("Hello, world!".getBytes("UTF-8"));
       	System.out.println(convert(inputStream));
   	}
   }
   

Conclusion

Converting an InputStream to a String in Java can be achieved through multiple approaches, each with advantages depending on the use case.

• For large files, using BufferedReader with StringBuilder is an efficient and memory-friendly approach.
• For Java 8+ users, the Stream API (BufferedReader.lines()) offers a clean and concise way to handle the conversion.
• If using Apache Commons IO, IOUtils.toString() is the simplest and most convenient option, reducing boilerplate code.
• For quick, compact code, the Scanner class with .useDelimiter("\\A") provides an easy way to read the entire stream at once.
• For byte-level operations, using ByteArrayOutputStream gives greater control over encoding and byte handling.

Ultimately, the best approach depends on your specific needs—whether it's performance, simplicity, or compatibility with third-party libraries.