Question Fichier à octet [] en Java


Comment puis-je convertir un java.io.File à un byte[]?


552
2018-05-13 16:30


origine


Réponses:


Cela dépend de ce que les meilleurs moyens pour vous. Productivité sage, ne pas réinventer la roue et utiliser Apache Commons. Qui est ici IOUtils.toByteArray(InputStream input).


386
2018-05-13 16:48



De JDK 7 vous pouvez utiliser Files.readAllBytes(Path).

Exemple:

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

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


153
2017-07-02 13:47



Depuis JDK 7 - un paquebot:

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

Aucune dépendance externe requise.


123
2018-05-13 17:08



Fondamentalement, vous devez le lire en mémoire. Ouvrez le fichier, allouez le tableau et lisez le contenu du fichier dans le tableau.

Le moyen le plus simple est quelque chose de similaire à ceci:

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

Cela a une copie inutile du contenu du fichier (en fait, les données sont copiées trois fois: du fichier à buffer, de buffer à ByteArrayOutputStream, de ByteArrayOutputStream au tableau résultant réel).

Vous devez également vous assurer de ne lire dans la mémoire que des fichiers d'une certaine taille (cela dépend généralement de l'application) :-).

Vous devez également traiter le IOException en dehors de la fonction.

Une autre façon est la suivante:

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

Cela n'a aucune copie inutile.

FileTooBigException est une exception d'application personnalisée. le MAX_FILE_SIZE constante est un paramètres d'application.

Pour les gros fichiers, vous devriez probablement penser à un algorithme de traitement de flux ou utiliser un mappage de mémoire (voir java.nio).


72
2018-05-13 16:57



Comme quelqu'un l'a dit, Apache Commons Utils de fichiers pourrait avoir ce que vous cherchez

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

Exemple d'utilisation (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



Vous pouvez également utiliser l'API NIO pour le faire. Je pourrais le faire avec ce code tant que la taille totale du fichier (en octets) rentrerait dans 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();
    }
}

Je pense que c'est très rapide depuis son utilisation de 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 vous n'avez pas Java 8, et convenez avec moi qu'inclure une bibliothèque massive pour éviter d'écrire quelques lignes de code est une mauvaise idée:

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

L'appelant est responsable de la fermeture du flux.


16
2018-01-23 08:59



Façon simple de le faire:

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