Archivo a byte [] en Java


Answers

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

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




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



Desde JDK 7 - un trazador de líneas:

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

No se necesitan dependencias externas.




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



ReadFully Lee b.length bytes de este archivo en la matriz de bytes, comenzando en el puntero del archivo actual. Este método lee repetidamente del archivo hasta que se lee el número solicitado de bytes. Este método bloquea hasta que se lee el número solicitado de bytes, se detecta el final de la secuencia o se lanza una excepción.

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



Como alguien dijo, Apache Commons File Utils puede 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);
        ...
    }
}



Si desea leer bytes en un búfer de bytes preasignado, esta respuesta puede ayudar.

Su primera suposición probablemente sea utilizar InputStream read(byte[]) . Sin embargo, este método tiene un defecto que lo hace irrazonablemente difícil de usar: no hay garantía de que la matriz esté completamente llena, incluso si no se encuentra EOF.

En su lugar, eche un vistazo a DataInputStream readFully(byte[]) . Este es un contenedor para flujos de entrada y no tiene el problema mencionado anteriormente. Además, este método arroja cuando se encuentra EOF. Mucho más bonito.




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



Otra forma de leer bytes del archivo

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



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.