webentwicklung-frage-antwort-db.com.de

Android: Wie kann ich die Datei in Bytes lesen?

Ich versuche, Dateiinhalte in Bytes in der Android-Anwendung abzurufen. Ich habe die datei auf sd-karte bekommen will nun die ausgewählte datei in bytes bekommen. Ich habe gegoogelt, aber keinen solchen Erfolg. Bitte helfen

Nachfolgend finden Sie den Code zum Abrufen von Dateien mit der Erweiterung. Dadurch bekomme ich Dateien und zeige es in Spinner. Bei der Dateiauswahl möchte ich die Datei in Bytes erhalten.

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

hier ist es einfach:

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

Fügen Sie die Berechtigung in manifest.xml hinzu:

 <uses-permission Android:name="Android.permission.READ_EXTERNAL_STORAGE" />
93
idiottiger

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

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

ANMERKUNG: Es wird davon ausgegangen, dass die Dateigröße weniger als MAX_INT Bytes beträgt. Sie können die Behandlung hinzufügen, wenn Sie möchten. 

18
Siavash

Die einfachste Lösung heute ist die Verwendung von Apache common io:

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 besteht darin, diese Abhängigkeit in Ihrer build.gradle-App hinzuzufügen:

implementation 'commons-io:commons-io:2.5'

+ 1562 Methoden zählen

14
Renaud Boulard

Da der akzeptierte BufferedInputStream#read nicht garantiert, alles zu lesen, anstatt die Puffergrößen selbst zu verfolgen, habe ich diesen Ansatz verwendet:

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

Blockiert, bis ein vollständiger Lesevorgang abgeschlossen ist und keine zusätzlichen Importe erforderlich sind.

11
lase

Wenn Sie hierfür die Methode openFileInput aus einem Kontext verwenden möchten, können Sie den folgenden Code verwenden.

Dadurch wird ein BufferArrayOutputStream erstellt und jedes Byte beim Lesen aus der Datei angehängt.

/**
 * <p>
 *     Creates a InputStream for a file using the specified Context
 *     and returns the Bytes read from the file.
 * </p>
 *
 * @param context The context to use.
 * @param file The file to read from.
 * @return The array of bytes read from the file, or null if no file was found.
 */
public static byte[] read(Context context, String file) throws IOException {
    byte[] ret = null;

    if (context != null) {
        try {
            InputStream inputStream = context.openFileInput(file);
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

            int nextByte = inputStream.read();
            while (nextByte != -1) {
                outputStream.write(nextByte);
                nextByte = inputStream.read();
            }

            ret = outputStream.toByteArray();

        } catch (FileNotFoundException ignored) { }
    }

    return ret;
}
0
Nathan F.

Ein einfacher InputStream reicht aus

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;
}
0
Ilya Gazman

Sie können es auch so machen:

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

Im Folgenden finden Sie die funktionierende Lösung zum Lesen der gesamten Datei in Blöcken und die effiziente Lösung zum Lesen großer Dateien mithilfe einer Scannerklasse.

   try {
        FileInputStream fiStream = new FileInputStream(inputFile_name);
        Scanner sc = null;
        try {
            sc = new Scanner(fiStream);
            while (sc.hasNextLine()) {
                String line = sc.nextLine();
                byte[] buf = line.getBytes();
            }
        } finally {
            if (fiStream != null) {
                fiStream.close();
            }

            if (sc != null) {
                sc.close();
            }
        }
    }catch (Exception e){
        Log.e(TAG, "Exception: " + e.toString());
    }
0
Prasanth.NVS