Pregunta Archivo a byte [] en Java


¿Cómo convierto un java.io.File a un byte[]?


552
2018-05-13 16:30


origen


Respuestas:


Depende de lo que sea mejor para ti. Productividad, no reinvente la rueda y use Apache Commons. Que esta aqui IOUtils.toByteArray(InputStream input).


386
2018-05-13 16:48



De JDK 7 puedes usar Files.readAllBytes(Path).

Ejemplo:

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);

1023
2017-12-08 13:57



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

Documentación para Java 8: http://docs.oracle.com/javase/8/docs/api/java/io/RandomAccessFile.html


153
2017-07-02 13:47



Desde JDK 7 - un trazador de líneas:

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

No se necesitan dependencias externas.


123
2018-05-13 17:08



Básicamente, debes leerlo en la memoria. Abra el archivo, asigne la matriz y lea los contenidos del archivo en la matriz.

La forma más simple es algo similar a esto:

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();
}

Esto tiene una copia innecesaria del contenido del archivo (en realidad, los datos se copian tres veces: de un archivo a buffer, de buffer a ByteArrayOutputStream, de ByteArrayOutputStream a la matriz real resultante).

También debe asegurarse de leer en la memoria solo los archivos de un determinado tamaño (esto generalmente depende de la aplicación) :-).

También necesita tratar el IOException fuera de la función.

Otra forma es esto:

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;
}

Esto no tiene copia innecesaria.

FileTooBigException es una excepción de aplicación personalizada. los MAX_FILE_SIZE constante es un parámetro de la aplicación.

Para archivos grandes, probablemente deberías pensar en un algoritmo de procesamiento de flujo o usar un mapeo de memoria (ver java.nio)


72
2018-05-13 16:57



Como alguien dijo, Apache Commons File Utils podría tener lo que estás buscando

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

Ejemplo de uso (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);
        ...
    }
}

63
2018-05-13 16:32



Puedes usar la API de NIO también para hacerlo. Podría hacer esto con este código siempre que el tamaño total del archivo (en bytes) encaje en un 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();
    }
}

Creo que es muy rápido ya que usa MappedByteBuffer.


19
2017-07-06 23:06



// 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;
    }

17
2018-02-23 13:19



Si no tiene Java 8, y está de acuerdo conmigo, incluir una biblioteca masiva para evitar escribir algunas líneas de código es una mala 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();
}

La persona que llama es responsable de cerrar la transmisión.


16
2018-01-23 08:59



Manera simple de hacerlo:

File fff = new File("/path/to/file");
FileInputStream fileInputStream = new FileInputStream(fff);

// int byteLength = fff.length(); 

// In android the result of file.length() is long
long byteLength = fff.length(); // byte count of the file-content

byte[] filecontent = new byte[(int) byteLength];
fileInputStream.read(filecontent, 0, (int) byteLength);

13
2018-04-17 15:12



Manera más simple para leer bytes desde el archivo

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);
        }
    }
}

11
2018-02-24 13:00