Home » Java » File to byte[] in Java

File to byte[] in Java

Posted by: admin November 2, 2017 Leave a comment

Questions:

How do I convert a java.io.File to a byte[]?

Answers:

It depends on what best means for you. Productivity wise, don’t reinvent the wheel and use Apache Commons. Which is here IOUtils.toByteArray(InputStream input).

Questions:
Answers:

From JDK 7 you can use Files.readAllBytes(Path).

Example:

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.Path;

Path path = Paths.get("path/to/file");
byte[] data = Files.readAllBytes(path);

Questions:
Answers:
import java.io.RandomAccessFile;
RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);

Documentation for Java 8: http://docs.oracle.com/javase/8/docs/api/java/io/RandomAccessFile.html

Questions:
Answers:

Since JDK 7 – one liner:

byte[] array = Files.readAllBytes(new File("/path/to/file").toPath());

No external dependencies needed.

Questions:
Answers:

Basically you have to read it in memory. Open the file, allocate the array, and read the contents from the file into the array.

The simplest way is something similar to this:

public byte[] read(File file) throws IOException, FileTooBigException {
    if (file.length() > MAX_FILE_SIZE) {
        throw new FileTooBigException(file);
    }
    ByteArrayOutputStream ous = null;
    InputStream ios = null;
    try {
        byte[] buffer = new byte[4096];
        ous = new ByteArrayOutputStream();
        ios = new FileInputStream(file);
        int read = 0;
        while ((read = ios.read(buffer)) != -1) {
            ous.write(buffer, 0, read);
        }
    }finally {
        try {
            if (ous != null)
                ous.close();
        } catch (IOException e) {
        }

        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
        }
    }
    return ous.toByteArray();
}

This has some unnecessary copying of the file content (actually the data is copied three times: from file to buffer, from buffer to ByteArrayOutputStream, from ByteArrayOutputStream to the actual resulting array).

You also need to make sure you read in memory only files up to a certain size (this is usually application dependent) :-).

You also need to treat the IOException outside the function.

Another way is this:

public byte[] read(File file) throws IOException, FileTooBigException {
    if (file.length() > MAX_FILE_SIZE) {
        throw new FileTooBigException(file);
    }

    byte[] buffer = new byte[(int) file.length()];
    InputStream ios = null;
    try {
        ios = new FileInputStream(file);
        if (ios.read(buffer) == -1) {
            throw new IOException(
                    "EOF reached while trying to read the whole file");
        }
    } finally {
        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
        }
    }
    return buffer;
}

This has no unnecessary copying.

FileTooBigException is a custom application exception.
The MAX_FILE_SIZE constant is an application parameters.

For big files you should probably think a stream processing algorithm or use memory mapping (see java.nio).

Questions:
Answers:

As someone said, Apache Commons File Utils might have what you are looking for

public static byte[] readFileToByteArray(File file) throws IOException

Example use (Program.java):

import org.apache.commons.io.FileUtils;
public class Program {
    public static void main(String[] args) throws IOException {
        String fileName = ...
        byte[] data = FileUtils.readFileToByteArray(fileName);
        ...
    }
}

Questions:
Answers:

You can use the NIO api as well to do it. I could do this with this code as long as the total file size (in bytes) would fit in an int.

    File f = new File("c:\wscp.script");
    FileInputStream fin = null;
    FileChannel ch = null;
    try {
        fin = new FileInputStream(f);
        ch = fin.getChannel();
        int size = (int) ch.size();
        MappedByteBuffer buf = ch.map(MapMode.READ_ONLY, 0, size);
        byte[] bytes = new byte[size];
        buf.get(bytes);

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        try {
            if (fin != null) {
                fin.close();
            }
            if (ch != null) {
                ch.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

I think its very fast since its using MappedByteBuffer.

Questions:
Answers:
// Returns the contents of the file in a byte array.
    public static byte[] getBytesFromFile(File file) throws IOException {        
        // Get the size of the file
        long length = file.length();

        // You cannot create an array using a long type.
        // It needs to be an int type.
        // Before converting to an int type, check
        // to ensure that file is not larger than Integer.MAX_VALUE.
        if (length > Integer.MAX_VALUE) {
            // File is too large
            throw new IOException("File is too large!");
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[(int)length];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;

        InputStream is = new FileInputStream(file);
        try {
            while (offset < bytes.length
                   && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
                offset += numRead;
            }
        } finally {
            is.close();
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file "+file.getName());
        }
        return bytes;
    }

Questions:
Answers:

Guava has Files.toByteArray() to offer you. It has several advantages:

  1. It covers the corner case where files report a length of 0 but still have content
  2. It’s highly optimized, you get a OutOfMemoryException if trying to read in a big file before even trying to load the file. (Through clever use of file.length())
  3. You don’t have to reinvent the wheel.
Questions:
Answers:

Simplest Way for reading bytes from file

import java.io.*;
class ReadBytesFromFile{
public static void main(String args[])throws Exception{


/// getBytes from anyWhere
// I'm getting byte array from File
File file=null;
FileInputStream fileStream=new FileInputStream(file=new File("ByteArrayInputStreamClass.java"));

    // Instantiate array
    byte []arr= new byte[(int)file.length()];

    /// read All bytes of File stream
    fileStream.read(arr,0,arr.length);

    for (int X : arr){
        System.out.print((char)X);
    }


}
}

Questions:
Answers:

If you don’t have Java 8, and agree with me that including a massive library to avoid writing a few lines of code is a bad idea:

  public static byte[] readBytes(InputStream inputStream) throws IOException {
    byte[] b = new byte[1024];
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    int c;
    while ((c = inputStream.read(b)) != -1) {
      os.write(b, 0, c);
    }
    return os.toByteArray();
  }

Caller is responsible for closing the stream.

Questions:
Answers:

Simple way to do it:

    File fff = new File("/path/to/file");
    FileInputStream fileInputStream = new FileInputStream(fff);
    int byteLength=fff.length(); //bytecount of the file-content
    byte[] filecontent = new byte[byteLength];
    fileInputStream.read(filecontent,0,byteLength);

Questions:
Answers:

Using the same approach as the community wiki answer, but cleaner and compiling out of the box (preferred approach if you don’t want to import Apache Commons libs, e.g. on Android):

public static byte[] getFileBytes(File file) throws IOException {
    ByteArrayOutputStream ous = null;
    InputStream ios = null;
    try {
        byte[] buffer = new byte[4096];
        ous = new ByteArrayOutputStream();
        ios = new FileInputStream(file);
        int read = 0;
        while ((read = ios.read(buffer)) != -1)
            ous.write(buffer, 0, read);
    } finally {
        try {
            if (ous != null)
                ous.close();
        } catch (IOException e) {
            // swallow, since not that important
        }
        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
            // swallow, since not that important
        }
    }
    return ous.toByteArray();
}

Questions:
Answers:
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;

File file = getYourFile();
Path path = file.toPath();
byte[] data = Files.readAllBytes(path);

Questions:
Answers:

I belive this is the easiest way:

org.apache.commons.io.FileUtils.readFileToByteArray(file);

Questions:
Answers:

ReadFully Reads b.length bytes from this file into the byte array, starting at the current file pointer. This method reads repeatedly from the file until the requested number of bytes are read. This method blocks until the requested number of bytes are read, the end of the stream is detected, or an exception is thrown.

RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);

Questions:
Answers:

Let me add another solution without using third-party libraries. It re-uses an exception handling pattern that was proposed by Scott (link). And I moved the ugly part into a separate message (I would hide in some FileUtils class 😉 )

public void someMethod() {
    final byte[] buffer = read(new File("test.txt"));
}

private byte[] read(final File file) {
    if (file.isDirectory())
        throw new RuntimeException("Unsupported operation, file "
                + file.getAbsolutePath() + " is a directory");
    if (file.length() > Integer.MAX_VALUE)
        throw new RuntimeException("Unsupported operation, file "
                + file.getAbsolutePath() + " is too big");

    Throwable pending = null;
    FileInputStream in = null;
    final byte buffer[] = new byte[(int) file.length()];
    try {
        in = new FileInputStream(file);
        in.read(buffer);
    } catch (Exception e) {
        pending = new RuntimeException("Exception occured on reading file "
                + file.getAbsolutePath(), e);
    } finally {
        if (in != null) {
            try {
                in.close();
            } catch (Exception e) {
                if (pending == null) {
                    pending = new RuntimeException(
                        "Exception occured on closing file" 
                             + file.getAbsolutePath(), e);
                }
            }
        }
        if (pending != null) {
            throw new RuntimeException(pending);
        }
    }
    return buffer;
}

Questions:
Answers:

If you want to read bytes into a pre-allocated byte buffer, this answer may help.

Your first guess would probably be to use InputStream read(byte[]). However, this method has a flaw that makes it unreasonably hard to use: there is no guarantee that the array will actually be completely filled, even if no EOF is encountered.

Instead, take a look at DataInputStream readFully(byte[]). This is a wrapper for input streams, and does not have the above mentioned issue. Additionally, this method throws when EOF is encountered. Much nicer.

Questions:
Answers:
public static byte[] readBytes(InputStream inputStream) throws IOException {
    byte[] buffer = new byte[32 * 1024];
    int bufferSize = 0;
    for (;;) {
        int read = inputStream.read(buffer, bufferSize, buffer.length - bufferSize);
        if (read == -1) {
            return Arrays.copyOf(buffer, bufferSize);
        }
        bufferSize += read;
        if (bufferSize == buffer.length) {
            buffer = Arrays.copyOf(buffer, bufferSize * 2);
        }
    }
}

Questions:
Answers:

Another Way for reading bytes from file

Reader reader = null;
    try {
        reader = new FileReader(file);
        char buf[] = new char[8192];
        int len;
        StringBuilder s = new StringBuilder();
        while ((len = reader.read(buf)) >= 0) {
            s.append(buf, 0, len);
            byte[] byteArray = s.toString().getBytes();
        }
    } catch(FileNotFoundException ex) {
    } catch(IOException e) {
    }
    finally {
        if (reader != null) {
            reader.close();
        }
    }