1. Overview
In this quick tutorial, we’ll illustrate how to write an InputStream to a File. First we’ll use plain Java, then Guava, and finally the Apache Commons IO library.
This article is part of the “Java – Back to Basic” tutorial here on Baeldung.
How to convert an InputStream to a Reader using Java, Guava and the Apache Commons IO library.
How to open an InputStream from a Java File - using plain Java, Guava and the Apache Commons IO library.
How to convert an InputStream to a byte[] using plain Java, Guava or Commons IO.
2. Convert Using Plain Java
Let’s start with the Java solution:
@Test
public void whenConvertingToFile_thenCorrect() throws IOException {
Path path = Paths.get("src/test/resources/sample.txt");
byte[] buffer = java.nio.file.Files.readAllBytes(path);
File targetFile = new File("src/test/resources/targetFile.tmp");
OutputStream outStream = new FileOutputStream(targetFile);
outStream.write(buffer);
IOUtils.closeQuietly(outStream);
}
Note that in this example, the input stream has known and pre-determined data, such as a file on disk or an in-memory stream. As a result, we don’t need to do any bounds checking and we can, if memory allows, simply read it and write it in one go.
If the input stream is linked to an ongoing stream of data, like an HTTP response coming from an ongoing connection, then reading the entire stream once isn’t an option. In that case, we need to make sure we keep reading until we reach the end of the stream:
@Test
public void whenConvertingInProgressToFile_thenCorrect()
throws IOException {
InputStream initialStream = new FileInputStream(
new File("src/main/resources/sample.txt"));
File targetFile = new File("src/main/resources/targetFile.tmp");
OutputStream outStream = new FileOutputStream(targetFile);
byte[] buffer = new byte[8 * 1024];
int bytesRead;
while ((bytesRead = initialStream.read(buffer)) != -1) {
outStream.write(buffer, 0, bytesRead);
}
IOUtils.closeQuietly(initialStream);
IOUtils.closeQuietly(outStream);
}
Finally, here’s another simple way we can use Java 8 to do the same operation:
@Test
public void whenConvertingAnInProgressInputStreamToFile_thenCorrect2()
throws IOException {
InputStream initialStream = new FileInputStream(
new File("src/main/resources/sample.txt"));
File targetFile = new File("src/main/resources/targetFile.tmp");
java.nio.file.Files.copy(
initialStream,
targetFile.toPath(),
StandardCopyOption.REPLACE_EXISTING);
IOUtils.closeQuietly(initialStream);
}
3. Convert Using Guava
Next, let’s take a look at a simpler Guava based solution:
@Test
public void whenConvertingInputStreamToFile_thenCorrect3()
throws IOException {
InputStream initialStream = new FileInputStream(
new File("src/main/resources/sample.txt"));
byte[] buffer = new byte[initialStream.available()];
initialStream.read(buffer);
File targetFile = new File("src/main/resources/targetFile.tmp");
Files.write(buffer, targetFile);
}
4. Convert Using Commons IO
Finally, here’s an even quicker solution with Apache Commons IO:
@Test
public void whenConvertingInputStreamToFile_thenCorrect4()
throws IOException {
InputStream initialStream = FileUtils.openInputStream
(new File("src/main/resources/sample.txt"));
File targetFile = new File("src/main/resources/targetFile.tmp");
FileUtils.copyInputStreamToFile(initialStream, targetFile);
}
And there we have it, 3 quick ways of writing the InputStream to a File.
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.
