1. Overview
In this quick tutorial, we’ll see how to convert a file to a byte array in Java.
First, we’ll learn how to do it using built-in JDK solutions. Then, we’ll discuss how to achieve the same result using Apache Commons IO and Guava.
2. Using Java
JDK provides several convenient ways to convert a file into an array of bytes. For example, we can use the java.io or java.nio packages to answer our central question. So, let’s take a close look at each option.
Let’s start with the easiest solution using the FileInputStream class from the IO package. Typically, this class comes with methods to read the content of a file as bytes.
For instance, let’s assume we have a file named sample.txt with the content “Hello World”:
class FileToByteArrayUnitTest {
private static final String FILE_NAME = "src" + File.separator + "test" + File.separator + "resources" + File.separator + "sample.txt";
private final byte[] expectedByteArray = { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100 };
@Test
void givenFile_whenUsingFileInputStreamClass_thenConvert() throws IOException {
File myFile = new File(FILE_NAME);
byte[] byteArray = new byte[(int) myFile.length()];
try (FileInputStream inputStream = new FileInputStream(myFile)) {
inputStream.read(byteArray);
}
assertArrayEquals(expectedByteArray, byteArray);
}
}
Here, we created an instance of the FileInputStream class using the given sample.txt file. Furthermore, we invoked the read(byte[] b) method to read the data from the FileInputStream instance into the defined array of bytes.
It’s worth noting that we used the try-with-resources approach to handle the closure of the resources efficiently.
2.2. Files#readAllBytes
Alternatively, we can use the Files class from the NIO API. As the name implies, this utility class offers multiple ready-to-use static methods for working with files and directories.
So, let’s see it in action:
@Test
void givenFile_whenUsingNioApiFilesClass_thenConvert() throws IOException {
byte[] byteArray = Files.readAllBytes(Paths.get(FILE_NAME));
assertArrayEquals(expectedByteArray, byteArray);
}
As we can see, the Files class comes with the readAllBytes() method which returns all the bytes from the specified path file. Interestingly, this method closes the file automatically when the bytes have been read.
Another important caveat here is that this method isn’t intended to read large files. So, we can use it only for simple cases.
3. Using Apache Commons IO
Another solution would be using the Apache Commons IO library. It offers a host of handy utility classes that we can use to perform common IO tasks.
First, let’s add the commons-io dependency to the pom.xml file:
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.15.1</version>
</dependency>
3.1. FileUtils#readFileToByteArray
The FileUtils class, as the name indicates, provides a set of methods for file manipulation. Among these methods, we find the readFileToByteArray() method:
@Test
void givenFile_whenUsingApacheCommonsFileUtilsClass_thenConvert() throws IOException {
byte[] byteArray = FileUtils.readFileToByteArray(new File(FILE_NAME));
assertArrayEquals(expectedByteArray, byteArray);
}
As we see above, readFileToByteArray() reads the content of the specified file into a byte array in a straightforward way. The good thing about this method is that the file is always closed.
Also, this method doesn’t have the limitations of Files#readAllBytes and throws NullPointerException if the provided file is null.
3.2. IOUtils#toByteArray
Apache Commons IO provides another alternative that we can use to achieve the same outcome. It offers the IOUtils class to handle general IO stream operations.
So, let’s exemplify the use of IOUtils using a practical example:
@Test
void givenFile_whenUsingApacheCommonsIOUtilsClass_thenConvert() throws IOException {
File myFile = new File(FILE_NAME);
byte[] byteArray = new byte[(int) myFile.length()];
try (FileInputStream inputStream = new FileInputStream(myFile)) {
byteArray = IOUtils.toByteArray(inputStream);
}
assertArrayEquals(expectedByteArray, byteArray);
}
In short, the class comes with the toByteArray() method to return the data of an InputStream as a byte[]. We don’t need to use BufferedInputStream here since this method buffers the content internally.
4. Using Guava
Guava library is another option to consider when converting a file to a byte array. As usual, before starting to work with this library, we need to add its dependency to pom.xml:
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>32.1.3-jre</version>
</dependency>
4.1. Files#toByteArray
The Guava library provides its own version of the Files class. So, let’s see it in practice:
@Test
void givenFile_whenUsingGuavaFilesClass_thenConvert() throws IOException {
byte[] byteArray = com.google.common.io.Files.toByteArray(new File(FILE_NAME));
assertArrayEquals(expectedByteArray, byteArray);
}
In a nutshell, we use the toByteArray() method to get a byte array containing all the bytes from the given file.
5. Conclusion
In this short article, we explored various ways to convert a file to a byte array using JDK methods, Guava, and Apache Commons IO libraries.
As always, the code used in this article can be found over on GitHub.
