Android: come leggere il file in byte?

Question

Sto cercando di ottenere il contenuto del file in byte nell'applicazione Android. Ho ottenuto il file nella scheda SD ora voglio ottenere il file selezionato in byte. Ho cercato su Google ma nessun tale successo. Please help

Di seguito è riportato il codice per ottenere file con estensione. Attraverso questo ottengo file e mostra in spinner. Sulla selezione del file voglio ottenere il file in byte.

private List<String> getListOfFiles(String path) { 

    File files = new File(path); 

    FileFilter filter = new FileFilter() { 

     private final List<String> exts = Arrays.asList("jpeg", "jpg", "png", "bmp", "gif","mp3"); 

     public boolean accept(File pathname) { 
     String ext; 
     String path = pathname.getPath(); 
     ext = path.substring(path.lastIndexOf(".") + 1); 
     return exts.contains(ext); 
     } 
    }; 

    final File [] filesFound = files.listFiles(filter); 
    List<String> list = new ArrayList<String>(); 
    if (filesFound != null && filesFound.length > 0) { 
     for (File file : filesFound) { 
     list.add(file.getName()); 
     } 
    } 
    return list; 
} 

Answer 1

qui si tratta di un semplice:

File file = new File(path); 
int size = (int) file.length(); 
byte[] bytes = new byte[size]; 
try { 
    BufferedInputStream buf = new BufferedInputStream(new FileInputStream(file)); 
    buf.read(bytes, 0, bytes.length); 
    buf.close(); 
} catch (FileNotFoundException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
} catch (IOException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
} 

Aggiungi autorizzazione manifest.xml:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> 

Answer 2

Ecco una soluzione che garantisce intero file verrà letto, che non richiede le librerie e è efficiente:

byte[] fullyReadFileToBytes(File f) throws IOException { 
    int size = (int) f.length(); 
    byte bytes[] = new byte[size]; 
    byte tmpBuff[] = new byte[size]; 
    FileInputStream fis= new FileInputStream(f);; 
    try { 

     int read = fis.read(bytes, 0, size); 
     if (read < size) { 
      int remain = size - read; 
      while (remain > 0) { 
       read = fis.read(tmpBuff, 0, remain); 
       System.arraycopy(tmpBuff, 0, bytes, size - remain, read); 
       remain -= read; 
      } 
     } 
    } catch (IOException e){ 
     throw e; 
    } finally { 
     fis.close(); 
    } 

    return bytes; 
} 

NOTA: presuppone che la dimensione del file sia inferiore a MAX_INT byte, è possibile aggiungere la gestione per questo se lo si desidera.

Answer 3

La soluzione più semplice oggi è quella di utilizzare Apache io comune:

http://commons.apache.org/proper/commons-io/javadocs/api-release/org/apache/commons/io/FileUtils.html#readFileToByteArray(java.io.File)

byte bytes[] = FileUtils.readFileToByteArray(photoFile) 

L'unico svantaggio è quello di aggiungere questa dipendenza nel vostro build.gradle app:

compile 'commons-io:commons-io:2.4' 

+ 1562 Metodi conta

Answer 4

Tu può anche fare in questo modo:

byte[] getBytes (File file) 
{ 
    FileInputStream input = null; 
    if (file.exists()) try 
    { 
     input = new FileInputStream (file); 
     int len = (int) file.length(); 
     byte[] data = new byte[len]; 
     int count, total = 0; 
     while ((count = input.read (data, total, len - total)) > 0) total += count; 
     return data; 
    } 
    catch (Exception ex) 
    { 
     ex.printStackTrace(); 
    } 
    finally 
    { 
     if (input != null) try 
     { 
      input.close(); 
     } 
     catch (Exception ex) 
     { 
      ex.printStackTrace(); 
     } 
    } 
    return null; 
} 

Answer 5

Dal accettato la BufferedInputStream#read non è garantita a leggere tutto, piuttosto che tenere traccia del buffer di dimensioni me stesso, ho usato questo approccio:

byte bytes[] = new byte[(int) file.length()]; 
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file)); 
    DataInputStream dis = new DataInputStream(bis); 
    dis.readFully(bytes); 

blocchi fino una lettura completa è completa e non richiede importazioni aggiuntive.

Answer 6

Un semplice InputStream farà

byte[] fileToBytes(File file){ 
    byte[] bytes = new byte[0]; 
    try(FileInputStream inputStream = new FileInputStream(file)) { 
     bytes = new byte[inputStream.available()]; 
     //noinspection ResultOfMethodCallIgnored 
     inputStream.read(bytes); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return bytes; 
}