Fichier à byte [] en Java

comment convertir un java.io.File en un byte[] ?

571
demandé sur Duncan Jones 2009-05-13 20:30:33

21 réponses

cela dépend de ce que cela signifie pour vous. Du point de vue de la productivité, ne réinventez pas la roue et utilisez Apache Commons. Qui est ici IOUtils.toByteArray(InputStream input) .

391
répondu svachon 2016-08-01 12:26:45

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

exemple:

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

File file;
// ...(file is initialised)...
byte[] fileContent = Files.readAllBytes(file.toPath());
1052
répondu Michael Pollmeier 2018-08-03 07:42:00
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

154
répondu Dmitry Mitskevich 2016-07-19 12:20:31

depuis JDK 7-one liner:

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

aucune dépendance externe nécessaire.

128
répondu Paulius Matulionis 2015-09-15 12:57:50

en gros, il faut le lire en mémoire. Ouvrez le fichier, allouer le tableau, et de lire le contenu du fichier dans le tableau.

la manière la 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 quelques copies inutiles 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éel résultant).

vous devez également vous assurer que vous lisez en mémoire que les fichiers jusqu'à une certaine taille (ce qui est généralement dépendant de l'application) :-).

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

une autre façon est celle-ci:

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

il n'y a pas de copie inutile.

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

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

72
répondu Mihai Toader 2015-08-19 13:52:56

Comme quelqu'un a dit, Apache Commons Fichier Utils peut-être ce que vous êtes à la recherche pour

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 {
        File file = new File(args[0]);  // assume args[0] is the path to file
        byte[] data = FileUtils.readFileToByteArray(file);
        ...
    }
}
64
répondu Tom 2018-10-03 21:05:57

vous pouvez également utiliser l'api NIO. Je pourrais faire avec ce code tant que la taille totale du fichier (en octets) rentre 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 son très rapide depuis son utilisation MappedByteBuffer.

19
répondu Amit 2018-04-12 19:39:31
// 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
répondu Cuga 2011-08-15 16:23:13

Si vous n'avez pas Java 8, et d'accord avec moi que, y compris un énorme bibliothèque d'é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 fermer le flux.

16
répondu Jeffrey Blattman 2018-04-12 19:37:36

manière 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
répondu Sudip Bhandari 2018-04-12 19:33:49

la manière la plus simple de lire des octets à partir du fichier

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
répondu Muhammad Sadiq 2018-04-12 19:36:02

Goyave a "151910920 de Fichiers".toByteArray() à vous offrir. Il a plusieurs avantages:

  1. il couvre le cas du coin où les fichiers déclarent une longueur de 0 mais ont quand même du contenu
  2. il est fortement optimisé, vous obtenez un OutOfMemoryException si vous essayez de lire dans un grand fichier avant même d'essayer de charger le fichier. (Grâce à une utilisation intelligente du fichier.longueur())
  3. Vous n'avez pas à réinventer la roue.
10
répondu jontejj 2013-04-17 15:12:02

utilisant la même approche que la réponse wiki de la communauté, mais plus propre et compilant hors de la boîte (approche préférée si vous ne voulez pas importer les libs D'Apache Commons, par exemple sur 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();
}
8
répondu manmal 2012-02-24 13:00:22
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);
8
répondu BlondCode 2016-09-02 15:55:06

je crois que c'est la façon la plus facile:

org.apache.commons.io.FileUtils.readFileToByteArray(file);
5
répondu Cristian Tetic 2014-04-03 12:44:25

lit B. longueur des octets de ce fichier dans le tableau des octets, en commençant par le pointeur du fichier courant. Cette méthode lit à plusieurs reprises dans le fichier jusqu'à ce que le nombre d'octets lus. Cette méthode bloque jusqu'à ce que le nombre d'octets lus, la fin du flux est détecté, ou une exception est levée.

RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);
4
répondu Tarun M 2015-04-16 08:13:32

Permettez-moi d'ajouter une autre solution sans utiliser de bibliothèques tierces. Il réutilise un modèle de traitement d'exception proposé par Scott ( link ). Et j'ai déplacé le laid partie dans un autre message (je me cachais dans certains FileUtils classe ;) )

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;
}
3
répondu Andreas_D 2017-05-23 12:26:29

si vous voulez lire des octets dans un tampon d'octets pré-alloué, cette réponse peut vous aider.

votre première supposition serait probablement d'utiliser InputStream read(byte[]) . Cependant, cette méthode a un défaut qui la rend excessivement difficile à utiliser: il n'y a aucune garantie que le tableau sera réellement rempli, même si aucun EOF n'est rencontré.

à la place, regardez DataInputStream readFully(byte[]) . Ceci est un wrapper pour il n'a pas la question mentionnée ci-dessus. En outre, cette méthode lance lorsque L'EOF est rencontré. Beaucoup plus agréable.

3
répondu Laurens Holst 2012-10-12 21:03:10
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);
        }
    }
}
2
répondu mazatwork 2012-11-12 11:33:27

une Autre Façon pour la lecture des octets à partir d'un fichier

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();
        }
    }
1
répondu Muhammad Aamir Ali 2014-11-25 10:24:34

ne convertit pas seulement un java de la façon suivante.io.File to a byte [], j'ai également trouvé qu'il est le moyen le plus rapide de lire dans un fichier, lors de l'essai de nombreuses différentes Java file reading methods l'un contre l'autre:

de java.nio.fichier.Fichier.readAllBytes ()

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

public class ReadFile_Files_ReadAllBytes {
  public static void main(String [] pArgs) throws IOException {
    String fileName = "c:\temp\sample-10KB.txt";
    File file = new File(fileName);

    byte [] fileBytes = Files.readAllBytes(file.toPath());
    char singleChar;
    for(byte b : fileBytes) {
      singleChar = (char) b;
      System.out.print(singleChar);
    }
  }
}
0
répondu gomisha 2018-04-09 13:38:22