Arquivo para byte em Java

Como faço para converter um java.io.File para um byte[] ?

   

Depende do que melhor significa para você. Produtividade sábia, não reinvente a roda e use o Apache Commons. Qual é aqui IOUtils.toByteArray(InputStream input) .

A partir do JDK 7, você pode usar Files.readAllBytes(Path) .

Exemplo:

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

Documentação para o Java 8: http://docs.oracle.com/javase/8/docs/api/java/io/RandomAccessFile.html

Desde o JDK 7 – um forro:

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

Nenhuma dependência externa necessária.

Basicamente você tem que lê-lo na memory. Abra o arquivo, aloque a matriz e leia o conteúdo do arquivo na matriz.

A maneira mais simples é algo semelhante a isto:

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

Isso tem alguma cópia desnecessária do conteúdo do arquivo (na verdade, os dados são copiados três vezes: do arquivo para o buffer , do buffer para o ByteArrayOutputStream , do ByteArrayOutputStream para o array resultante real).

Você também precisa ter certeza de que você lê apenas arquivos em memory até um certo tamanho (isso geralmente é dependente de aplicativos) :-).

Você também precisa tratar a IOException fora da function.

Outra maneira é esta:

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

Isso não tem cópia desnecessária.

FileTooBigException é uma exceção de aplicativo personalizado. A constante MAX_FILE_SIZE é um parâmetro do aplicativo.

Para arquivos grandes, você provavelmente deve pensar em um algoritmo de processamento de stream ou usar mapeamento de memory (consulte java.nio ).

Como alguém disse, o Apache Commons File Utils pode ter o que você está procurando

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

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

Você também pode usar a NIO api para fazer isso. Eu poderia fazer isso com este código, desde que o tamanho total do arquivo (em bytes) coubesse em um 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(); } } 

Eu acho que é muito rápido desde o seu uso 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; } 

Se você não tiver o Java 8 e concordar comigo, include uma biblioteca enorme para evitar escrever algumas linhas de código é uma má ideia:

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

O chamador é responsável por fechar o stream.

Maneira simples de fazer isso:

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

Maneira mais simples de ler bytes do arquivo

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

Guava tem Files.toByteArray () para oferecer a você. Tem várias vantagens:

  1. Ele cobre o caso de canto em que os arquivos relatam um comprimento de 0, mas ainda têm conteúdo
  2. É altamente otimizado, você obtém um OutOfMemoryException se estiver tentando ler em um arquivo grande antes mesmo de tentar carregar o arquivo. (Através do uso inteligente de file.length ())
  3. Você não precisa reinventar a roda.

Usando a mesma abordagem da resposta do wiki da comunidade, mas mais limpa e compilando fora da checkbox (abordagem preferida se você não quiser importar bibliotecas do Apache Commons, por exemplo, no 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); 

Eu acredito que esta é a maneira mais fácil:

 org.apache.commons.io.FileUtils.readFileToByteArray(file); 

ReadFully Lê bytes b.length deste arquivo na matriz de bytes, iniciando no ponteiro de arquivo atual. Esse método lê repetidamente do arquivo até que o número solicitado de bytes seja lido. Esse método bloqueia até que o número solicitado de bytes seja lido, o final do stream seja detectado ou uma exceção seja lançada.

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

Deixe-me adicionar outra solução sem usar bibliotecas de terceiros. Ele reutiliza um padrão de tratamento de exceções proposto por Scott ( link ). E eu mudei a parte feia para uma mensagem separada (eu me escondia em alguma class FileUtils;))

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

Se você quiser ler bytes em um buffer de byte pré-alocado, essa resposta pode ajudar.

Seu primeiro palpite provavelmente seria usar InputStream read(byte[]) . No entanto, esse método tem uma falha que o torna excessivamente difícil de usar: não há garantia de que o array será realmente completamente preenchido, mesmo se nenhum EOF for encontrado.

Em vez disso, dê uma olhada no DataInputStream readFully(byte[]) . Este é um wrapper para streams de input e não tem o problema mencionado acima. Além disso, esse método é lançado quando o EOF é encontrado. Muito melhor.

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

1- maneira tradicional

A maneira de conversão tradicional é através do método read () de InputStream como o seguinte:

 public static byte[] convertUsingTraditionalWay(File file) { byte[] fileBytes = new byte[(int) file.length()]; try(FileInputStream inputStream = new FileInputStream(file)) { inputStream.read(fileBytes); } catch (Exception ex) { ex.printStackTrace(); } return fileBytes; } 

2- Java NIO

Com o Java 7, você pode fazer a conversão usando a class do utilitário Files do pacote nio:

 public static byte[] convertUsingJavaNIO(File file) { byte[] fileBytes = null; try { fileBytes = Files.readAllBytes(file.toPath()); } catch (Exception ex) { ex.printStackTrace(); } return fileBytes; } 

3- Apache Commons IO

Além do JDK, você pode fazer a conversão usando a biblioteca Apache Commons IO de duas maneiras:

3.1. IOUtils.toByteArray ()

 public static byte[] convertUsingIOUtils(File file) { byte[] fileBytes = null; try(FileInputStream inputStream = new FileInputStream(file)) { fileBytes = IOUtils.toByteArray(inputStream); } catch (Exception ex) { ex.printStackTrace(); } return fileBytes; } 

3.2. FileUtils.readFileToByteArray ()

 public static byte[] convertUsingFileUtils(File file) { byte[] fileBytes = null; try { fileBytes = FileUtils.readFileToByteArray(file); } catch(Exception ex) { ex.printStackTrace(); } return fileBytes; } 

Referência: Java – Converter arquivo em byte []

Outra maneira de ler bytes do arquivo

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

Não apenas o seguinte caminho converte um java.io.File em um byte [], como também o caminho mais rápido para ler em um arquivo, ao testar muitos methods diferentes de leitura de arquivos Java uns contra os outros:

java.nio.file.Files.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); } } }