Java – Write an InputStream to a File

1. Overview

In this quick tutorial, we’re going to illustrate how to write an InputStream to a File – first using plain Java, then Guava, and finally the Apache Commons IO library.

This article is part of the “Java – Back to Basic” tutorial here on VietMX’s Blog.

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. Because of this, 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 – for example, an HTTP response coming from an ongoing connection – then reading the entire stream once is not 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 yet 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

And finally – 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 you have it – 3 quick ways of writing the InputStream to a File.

The implementation of all these examples can be found in our GitHub project.