Convert a File to byte[] in Java

You will learn how to read a file's contents into a Java byte[], primarily with Files.readAllBytes(). You will also learn when this approach is appropriate, how to validate files, and what to use for large files.

A java.io.File does not contain a file's data. It is an object that represents a location on the file system, such as /tmp/report.pdf.

To get the file contents, Java must open that location and read its bytes. A byte[] is an in-memory array that can hold those raw bytes.

The most direct modern Java API is Files.readAllBytes(Path):

byte[] bytes = Files.readAllBytes(file.toPath());

This is useful for binary data such as images, PDFs, ZIP files, and uploaded documents. It can also read text files, although text should usually be decoded into a String with an explicit character set.

Because the entire file is loaded into memory, readAllBytes() is best for reasonably sized files. For large files, process the data as a stream instead of creating one large array.

Think of a File as a street address written on a card. The card tells you where a package is stored, but it is not the package itself.

• File = the address
• Path = a modern form of the address used by the NIO API
• byte[] = the package contents brought into your program's memory
• Files.readAllBytes(...) = asking a courier to collect the entire package at once

For a small package, collecting everything at once is convenient. For a huge package, it is better to receive it in smaller boxes using a stream.

Use File.toPath() to convert a File to a Path, then call Files.readAllBytes().

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

public class FileReaderExample {
    public static void main(String[] args) throws IOException {
        File file = new File("data.bin");

        byte[] contents = Files.readAllBytes(file.toPath());

        System.out.println("Read " + contents.length + " bytes");
    }
}

Files.readAllBytes() may throw an IOException when the file does not exist, cannot be read, or another input/output problem occurs. This example declares throws IOException to keep the code short.

For a text file, convert the bytes using a known character encoding:

import java.nio.charset.StandardCharsets;

String text = new String(contents, StandardCharsets.UTF_8);

Do not rely on the platform default encoding when the text format is known.

Consider this example:

File file = new File("notes.txt");
byte[] data = Files.readAllBytes(file.toPath());
System.out.println(data.length);

1. new File("notes.txt") creates a File object representing a file named notes.txt relative to the program's working directory. It does not read the file yet.
2. file.toPath() creates a Path representation of that location.
3. Files.readAllBytes(...) opens the file, reads every byte, closes the file resource, and returns the data as a new byte[].
4. The variable data now refers to the bytes stored in memory.
5. data.length prints the number of bytes read.

For a UTF-8 file containing Hi, the byte array usually contains two bytes: 72 and 105. Other characters may use multiple UTF-8 bytes.

Common uses for reading a file into a byte array include:

• File uploads: Read a small attachment before sending it in an HTTP request.
• Database storage: Store a small document or image in a binary database column.
• Cryptography: Hash, sign, or encrypt a file's bytes.
• Testing: Load a fixture file and compare its raw contents with expected output.
• Binary parsing: Read a small image, PDF, or custom binary format before interpreting its structure.

For example, calculating a SHA-256 hash begins with bytes:

byte[] fileBytes = Files.readAllBytes(file.toPath());
// Pass fileBytes to a hashing API.

For very large uploads or media files, avoid reading the full file into a byte[]; stream it to its destination instead.

In production code, developers usually validate the input before reading it and choose an approach based on file size.

A small-file validation pattern:

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

public static byte[] readFile(File file) throws IOException {
    if (file == null) {
        throw new IllegalArgumentException("File must not be null");
    }

    if (!file.isFile()) {
        throw new IllegalArgumentException("Expected a regular file: " + file);
    }

    if (!file.canRead()) {
        throw new IOException("File is not readable: " + file);
    }

    return Files.readAllBytes(file.toPath());
}

Typical project practices include:

• Use guard clauses to reject null, directories, and invalid paths early.
• Let IOException reach a layer that can report a useful error, retry, or return an API error response.
• Enforce an application-specific size limit before loading user-provided files.
• Use InputStream APIs for large data, network responses, or files that should be processed incrementally.
• Prefer Path and Files in new code; keep File mainly when an older API requires it.

Assuming File already contains bytes

This only creates a path reference; it does not load file content:

File file = new File("photo.jpg");

Call a reading method such as Files.readAllBytes(file.toPath()).

Casting a File to byte[]

This is invalid because the types represent different things:

// byte[] bytes = (byte[]) file; // Does not compile

Read the file contents instead.

Reading a huge file all at once

byte[] bytes = Files.readAllBytes(largeVideo.toPath());

This can use a large amount of heap memory and may cause OutOfMemoryError. Stream large files with Files.newInputStream().

Ignoring IOException

Files can be missing, locked, unreadable, or removed between validation and reading. Handle or declare IOException.

Treating arbitrary binary data as text

String value = new String(bytes); // Uses the platform default charset

For text, specify the character set:

String value = new String(bytes, StandardCharsets.UTF_8);

Do not convert an image, ZIP, or PDF to String; those are binary formats.

Using file.length() as a guarantee

file.length() can help enforce a rough size limit, but the file may change before it is read. Treat it as a check, not a guarantee.

File and Path both identify file-system locations. Path is the newer NIO.2 API type and works directly with the useful methods in java.nio.file.Files.

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

File file = new File("data.bin");
byte[] bytes = Files.readAllBytes(file.toPath());

• File identifies a location; it is not the contents.
• file.toPath() adapts a File for the Files API.
• Files.readAllBytes(...) returns every file byte in a new byte[].
• Handle or declare IOException.
• Use it for files that fit comfortably in memory.
• For text, decode explicitly:

String text = new String(bytes, StandardCharsets.UTF_8);

• For large files, use a buffered InputStream and process chunks.
• To write bytes back to a file:

Files.write(file.toPath(), bytes);

How do I convert a File to byte[] in Java?

Use Files.readAllBytes(file.toPath()). It reads the complete file and returns its contents as a byte array.

Does Files.readAllBytes() close the file?

Yes. The method manages opening and closing the file internally.

What Java version supports Files.readAllBytes()?

It is available in Java 7 and later as part of the NIO.2 file API.

Should I use FileInputStream instead?

Use an input stream when the file is large or when you want to process data gradually. For a small file that you need entirely in memory, Files.readAllBytes() is simpler.

Can I use this for images and PDFs?

Yes. A byte array represents raw binary data, so it can hold image, PDF, ZIP, and other file formats.

How do I convert the bytes back into text?

Use new String(bytes, StandardCharsets.UTF_8) when the file is UTF-8 text. Always choose the encoding that matches the file format.

What happens if the file does not exist?

Files.readAllBytes() throws an IOException, commonly a NoSuchFileException.

• Java Path — The modern representation of a file-system path used by Files methods.
• Java Files API — Provides methods for reading, writing, copying, and inspecting files.
• InputStream and buffering — Used to process large files in chunks rather than loading all bytes at once.
• Exception handling with IOException — Required when file operations can fail.
• Character encodings — Needed when converting text-file bytes to String values.
• Writing a byte array to a file — The reverse operation, commonly done with Files.write().
• File upload handling — A common application scenario involving binary file data.