Android: Wie liest man eine Datei in Bytes?

Question

Ich versuche, Dateiinhalt in Bytes in Android-Anwendung zu erhalten. Ich habe jetzt die Datei in SD-Karte bekommen wollen, um die ausgewählte Datei in Bytes zu bekommen. Ich googelte aber keinen solchen Erfolg. Bitte helfen Sie

Unten ist der Code, um Dateien mit der Erweiterung zu erhalten. Dadurch bekomme ich Dateien und zeige in Spinner. Bei Dateiauswahl möchte ich Datei in Bytes bekommen.

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

hier ist es eine einfache:

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

hinzufügen Erlaubnis in manifest.xml:

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

Answer 2

Hier ist eine Lösung, die gesamte Datei garantiert gelesen werden, dass keine Bibliotheken erfordert und ist effizient:

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

HINWEIS: Es wird davon ausgegangen, dass die Dateigröße weniger als MAX_INT Bytes beträgt. Falls gewünscht, können Sie eine Behandlung hinzufügen.

Answer 3

Die heute einfachste Lösung ist Apache gemeinsam io verwendet:

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) 

Der einzige Nachteil ist hinzuzufügen, diese dependancy in Ihrem build.gradle App:

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

+ 1562 Methods zählen

Answer 4

Sie kann es auch auf diese Weise tun:

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

Seit den akzeptierten BufferedInputStream#read nicht lesen alles garantiert, anstatt Spur des Puffers zu halten Größen selbst, habe ich diesen Ansatz:

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

Blöcke bis Ein vollständiger Lesevorgang ist abgeschlossen und erfordert keine zusätzlichen Importe.

Answer 6

wird ein einfaches Input

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