1. Overview
In this tutorial, we’ll look at how to convert an InputStream to a String.
We’ll start by using plain Java, including Java8/9 solutions, and then look into using the Guava and Apache Commons IO libraries as well.
This article is part of the “Java – Back to Basic” series here on Baeldung.
2. Converting With Java – StringBuilder
Let’s look at a simple, lower-level approach using plain Java, an InputStream and a simple StringBuilder:
@Test
public void givenUsingJava5_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(DEFAULT_SIZE);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
StringBuilder textBuilder = new StringBuilder();
try (Reader reader = new BufferedReader(new InputStreamReader
(inputStream, StandardCharsets.UTF_8))) {
int c = 0;
while ((c = reader.read()) != -1) {
textBuilder.append((char) c);
}
}
assertEquals(textBuilder.toString(), originalString);
}
3. Converting With Java 8 – BufferedReader
Java 8 brings a new lines() method to the BufferedReader. Let’s see how we can make use of it to convert an InputStream to a String:
@Test
public void givenUsingJava8_whenConvertingAnInputStreamToAString_thenCorrect() {
String originalString = randomAlphabetic(DEFAULT_SIZE);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
String text = new BufferedReader(
new InputStreamReader(inputStream, StandardCharsets.UTF_8))
.lines()
.collect(Collectors.joining("\n"));
assertThat(text, equalTo(originalString));
}
It’s important to mention that lines() uses the readLine() method under the hood. readLine() assumes that a line is terminated by any one of a line feed (“\n”), a carriage return (“\r”), or a carriage return followed immediately by a linefeed. In other words, it supports all the common End Of Line styles: Unix, Windows, and even old Mac OS.
On the other hand, *when we use Collectors.joining(), we need to explicitly decide which type of EOL we want to use for the created String*.
We could also use the Collectors.joining(System.lineSeparator()), in which case the output depends on the system settings.
4. Converting With Java 9 – InputStream.readAllBytes()
If we’re on Java 9 or above, we can utilize a new readAllBytes method added to the InputStream:
@Test
public void givenUsingJava9_whenConvertingAnInputStreamToAString_thenCorrect() throws IOException {
String originalString = randomAlphabetic(DEFAULT_SIZE);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
String text = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
assertThat(text, equalTo(originalString));
}
We need to be aware that this simple code is intended for simple cases where it’s convenient to read all bytes into a byte array. We shouldn’t use it for reading input streams with large amounts of data.
5. Converting With Java and a Scanner
Next, let’s look at a plain Java example using a standard text Scanner:
@Test
public void givenUsingJava7_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
String text = null;
try (Scanner scanner = new Scanner(inputStream, StandardCharsets.UTF_8.name())) {
text = scanner.useDelimiter("\\A").next();
}
assertThat(text, equalTo(originalString));
}
Note that the InputStream is going to be closed by the closing of the Scanner.
It’s also worth clarifying what useDelimiter(“\\A”) does. Here we passed the ‘\A’, which is a boundary marker regex that denotes the beginning of the input. Essentially, this means that the next() call reads the entire input stream.
The only reason this is a Java 7 example, and not a Java 5 one, is the use of the try-with-resources statement. If we turn that into a standard try-finally block, it will compile just fine with Java 5.
6. Converting Using ByteArrayOutputStream
Finally, let’s look at another plain Java example, this time using the ByteArrayOutputStream class:
@Test
public void givenUsingPlainJava_whenConvertingAnInputStreamToString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[1024];
while ((nRead = inputStream.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
buffer.flush();
byte[] byteArray = buffer.toByteArray();
String text = new String(byteArray, StandardCharsets.UTF_8);
assertThat(text, equalTo(originalString));
}
In this example, the InputStream is converted to a ByteArrayOutputStream by reading and writing byte blocks. Then the OutputStream is transformed to a byte array, which is used to create a String.
7. Converting With java.nio
Another solution is to copy the content of the InputStream to a file, and then convert it to a String:
@Test
public void givenUsingTempFile_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(DEFAULT_SIZE);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
Path tempFile =
Files.createTempDirectory("").resolve(UUID.randomUUID().toString() + ".tmp");
Files.copy(inputStream, tempFile, StandardCopyOption.REPLACE_EXISTING);
String result = new String(Files.readAllBytes(tempFile));
assertThat(result, equalTo(originalString));
}
Here we’re using the java.nio.file.Files class to create a temporary file, as well as to copy the content of the InputStream to the file. Then the same class is used to convert the file content to a String with the readAllBytes() method.
8. Converting With Guava
Let’s start with a Guava example leveraging the ByteSource functionality:
@Test
public void givenUsingGuava_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
ByteSource byteSource = new ByteSource() {
@Override
public InputStream openStream() throws IOException {
return inputStream;
}
};
String text = byteSource.asCharSource(Charsets.UTF_8).read();
assertThat(text, equalTo(originalString));
}
Let’s go over the steps:
- first – we wrap our InputStream into a ByteSource, and as far as we’re aware, this is the easiest way to do so.
- then – we view our ByteSource as a CharSource with a UTF8 charset.
- finally – we use the CharSource to read it as a String.
A simpler way of doing the conversion is with Guava, but the stream needs to be explicitly closed; luckily, we can simply use the try-with-resources syntax to take care of that:
@Test
public void givenUsingGuavaAndJava7_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
String text = null;
try (Reader reader = new InputStreamReader(inputStream)) {
text = CharStreams.toString(reader);
}
assertThat(text, equalTo(originalString));
}
9. Converting With Apache Commons IO
Now let’s look at how to do this with the Commons IO library.
An important caveat here is that, as opposed to Guava, neither of these examples will close the InputStream:
@Test
public void givenUsingCommonsIo_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
String text = IOUtils.toString(inputStream, StandardCharsets.UTF_8.name());
assertThat(text, equalTo(originalString));
}
We can also use a StringWriter to do the conversion:
@Test
public void givenUsingCommonsIoWithCopy_whenConvertingAnInputStreamToAString_thenCorrect()
throws IOException {
String originalString = randomAlphabetic(8);
InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
StringWriter writer = new StringWriter();
String encoding = StandardCharsets.UTF_8.name();
IOUtils.copy(inputStream, writer, encoding);
assertThat(writer.toString(), equalTo(originalString));
}
10. Conclusion
In this article, we learned how to convert an InputStream to a String. We started by using plain Java, and then explored how to use the Guava and Apache Commons IO libraries.
The implementation of all of these examples and code snippets is available over on GitHub.