Fichier à byte [] en Java
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)
.
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());
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
depuis JDK 7-one liner:
byte[] array = Files.readAllBytes(new File("/path/to/file").toPath());
aucune dépendance externe nécessaire.
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
).
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);
...
}
}
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.
// 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;
}
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.
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);
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);
}
}
}
Goyave a "151910920 de Fichiers".toByteArray() à vous offrir. Il a plusieurs avantages:
- il couvre le cas du coin où les fichiers déclarent une longueur de 0 mais ont quand même du contenu
- 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())
- Vous n'avez pas à réinventer la roue.
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();
}
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);
je crois que c'est la façon la plus facile:
org.apache.commons.io.FileUtils.readFileToByteArray(file);
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);
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;
}
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.
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);
}
}
}
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();
}
}
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);
}
}
}