Lettura/Scrittura Byte in un File Utilizzando Solo Java.IO

Sembra che questi stanno per essere il nucleo di utilità/metodi di libreria che deve essere eseguito su Android API 23 o poi.

Relativi metodi di libreria, trovo che la cosa migliore da fare nessuna ipotesi sul modo in cui le applicazioni si utilizzano questi metodi. In alcuni casi le applicazioni desideri ricevere controllato IOExceptions (perché i dati da un file deve esistere per l'applicazione al lavoro), in altri casi, le applicazioni non possono care anche se i dati non sono disponibili (perché i dati da un file di cache solo che è disponibile anche da una fonte primaria).

Quando si tratta di operazioni di I/O, non c'è mai una garanzia che le operazioni di successo (ad es. un utente di far cadere il telefono in bagno). La biblioteca dovrebbe riflettere e dare l'applicazione di una scelta su come gestire gli errori.

Per ottimizzare le prestazioni di I/O sempre supporre che il "buon cammino" e individuare gli errori di capire cosa è andato storto. Questo è contro intuitivo alla normale programmazione, ma fondamentale per il rapporto con storage I/O. Per esempio, solo per controllare se un file esiste prima di leggere da un file può rendere la vostra applicazione due volte più lento di tutti questi tipi di I/O azioni di aggiungere velocemente per rallentare l'applicazione. Appena si supponga che il file esiste e se si ottiene un errore, solo allora controllare se il file esiste.

Quindi, dato che quelle idee, le funzioni principali come potrebbe apparire:

public static void writeFile(File f, byte[] data) throws FileNotFoundException, IOException {
    try (FileOutputStream out = new FileOutputStream(f)) {
        out.write(data);
    }
}

public static int readFile(File f, byte[] data) throws FileNotFoundException, IOException {
    try (FileInputStream in = new FileInputStream(f)) {
        return in.read(data); 
    }
}

Note sull'implementazione:

• I metodi possono anche gettare runtime-le eccezioni, come NullPointerExceptions - questi metodi non sono mai intenzione di essere "bug free".
• Non credo che il buffer è necessario/voluto nei metodi di cui sopra in quanto solo un nativo di chiamata è fatto (vedi anche qui).
• Ora l'applicazione ha anche la possibilità di leggere solo l'inizio di un file.

Per rendere più facile per un'applicazione per leggere un file, un metodo supplementare può essere aggiunto. Ma è da notare che la biblioteca di rilevare eventuali errori e li la domanda, in quanto l'applicazione non è più possibile rilevare tali errori.

public static byte[] readFile(File f) throws FileNotFoundException, IOException {
    int fsize = verifyFileSize(f);
    byte[] data = new byte[fsize];
    int read = readFile(f, data);
    verifyAllDataRead(f, data, read);
    return data;
}

private static int verifyFileSize(File f) throws IOException {
    long fsize = f.length();
    if (fsize > Integer.MAX_VALUE) {
        throw new IOException("File size (" + fsize + " bytes) for " + f.getName() + " too large.");
    }
    return (int) fsize;
}

public static void verifyAllDataRead(File f, byte[] data, int read) throws IOException {
    if (read != data.length) {
        throw new IOException("Expected to read " + data.length 
                + " bytes from file " + f.getName() + " but got only " + read + " bytes from file.");
    }
}

Questa implementazione aggiunge un altro punto nascosto del fallimento: OutOfMemory al punto in cui i nuovi dati viene creata la matrice.

Per soddisfare i requisiti di applicazioni supplementari metodi possono essere aggiunti per aiutare con diversi scenari. Per esempio, diciamo che in applicazione davvero non si vuole affrontare con eccezioni checked:

public static void writeFileData(File f, byte[] data) {
    try {
        writeFile(f, data);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
}

public static byte[] readFileData(File f) {
    try {
        return readFile(f);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
    return null;
}

public static int readFileData(File f, byte[] data) {
    try {
        return readFile(f, data);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
    return -1;
}

private static void fileExceptionToRuntime(Exception e) {
    if (e instanceof RuntimeException) { // e.g. NullPointerException
        throw (RuntimeException)e;
    }
    RuntimeException re = new RuntimeException(e.toString());
    re.setStackTrace(e.getStackTrace());
    throw re;
}

Il metodo fileExceptionToRuntime è un'implementazione minima, ma mostra l'idea qui.

La libreria può anche aiutare un'applicazione per risolvere i problemi quando si verifica un errore. Per esempio, un metodo canReadFile(File f) potrebbe controllare se un file esiste ed è leggibile e non troppo grande. L'applicazione potrebbe chiamare una funzione di file-non riesce a leggere e verificare i motivi per cui un file non può essere letto. Lo stesso può essere fatto per la scrittura di un file.

Anche se non è possibile utilizzare le librerie di terze parti, è ancora possibile leggere il loro codice e imparare dalla loro esperienza. In Google Guava per esempio, è di solito di leggere un file in byte, come questo:

FileInputStream reader = new FileInputStream("test.txt");
byte[] result = ByteStreams.toByteArray(reader);

L'implementazione di base di questo è toByteArrayInternal. Prima di chiamare questo, si dovrebbe controllare:

• Not null file è passato (NullPointerException)
• Il file esiste (FileNotFoundException)

Dopo di che, si è ridotto per la gestione di un InputStream e questo dove IOExceptions provengono da. Durante la lettura dei flussi di di un sacco di cose al di fuori del controllo dell'applicazione possono andare male (settori danneggiati e altri problemi hardware, mal-funzionamento driver, OS diritti di accesso) e si manifestano con una IOException.

Io sono la copia di qui l'applicazione:

private static final int BUFFER_SIZE = 8192;

/** Max array length on JVM. */
private static final int MAX_ARRAY_LEN = Integer.MAX_VALUE - 8;

private static byte[] toByteArrayInternal(InputStream in, Queue<byte[]> bufs, int totalLen)
      throws IOException {
    // Starting with an 8k buffer, double the size of each successive buffer. Buffers are retained
    // in a deque so that there's no copying between buffers while reading and so all of the bytes
    // in each new allocated buffer are available for reading from the stream.
    for (int bufSize = BUFFER_SIZE;
        totalLen < MAX_ARRAY_LEN;
        bufSize = IntMath.saturatedMultiply(bufSize, 2)) {
      byte[] buf = new byte[Math.min(bufSize, MAX_ARRAY_LEN - totalLen)];
      bufs.add(buf);
      int off = 0;
      while (off < buf.length) {
        // always OK to fill buf; its size plus the rest of bufs is never more than MAX_ARRAY_LEN
        int r = in.read(buf, off, buf.length - off);
        if (r == -1) {
          return combineBuffers(bufs, totalLen);
        }
        off += r;
        totalLen += r;
      }
    }

    // read MAX_ARRAY_LEN bytes without seeing end of stream
    if (in.read() == -1) {
      // oh, there's the end of the stream
      return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

Come si può vedere la maggior parte della logica ha a che fare con la lettura di un file in blocchi. Questo è quello di gestire le situazioni, in cui non si conosce la dimensione del InputStream, prima di iniziare la lettura. Nel tuo caso, è solo bisogno di leggere i file e si dovrebbe essere in grado di conoscere la lunghezza di anticipo, in modo tale complessità può essere evitata.

L'altro controllo è OutOfMemoryException. In Java standard il limite è troppo grande, comunque in Android, sarà un valore molto più piccolo. Si dovrebbe verificare, prima di provare a leggere il file che c'è abbastanza memoria disponibile.