Java: Speicher effizient ByteArrayOutputStream

MappedByteBuffer könnte das sein, was du bist suchen für.

Ich bin überrascht, dass es so viel RAM zum Lesen einer Datei im Speicher, obwohl. Haben Sie konstruiert die ByteArrayOutputStream mit einer entsprechenden Kapazität? Wenn Sie noch nicht, der stream konnte zuteilen ein neues byte-array, wenn es in der Nähe des Ende der 40 MB, was bedeutet, dass Sie, zum Beispiel, haben einen vollen Puffer von 39 MB, und einen neuen Puffer zweimal die Größe. In der Erwägung, dass, wenn der stream hat die entsprechende Kapazität, wird es keine Umverteilung (schneller), und kein verschwendeter Speicher.

InformationsquelleAutor der Antwort JB Nizet

Wenn Sie wirklich wollen, um Karte die Datei in den Speicher, dann ein FileChannel ist der entsprechende Mechanismus.

Wenn alles, was Sie tun möchten, ist die Datei Lesen, in eine einfache byte[] (und müssen keine änderungen an diesem array werden sich wieder auf der Datei), dann einfach das Lesen in einer angemessen bemessenen byte[] aus einer normalen FileInputStream sollte ausreichen.

Guave hat - Dateien.toByteArray()die tut alles für Sie.

InformationsquelleAutor der Antwort Joachim Sauer

Wenn du 40 MB Daten sehe ich keinen Grund, warum es dauern würde, mehr als 40 MB zu erstellen, die ein byte[]. Ich nehme an, Sie sind mit einer wachsenden ByteArrayOutputStream erzeugt einen byte[] zu kopieren, wenn Sie fertig sind.

Können Sie versuchen, die alten Lesen Sie die Datei auf einmal Ansatz.

File file = 
DataInputStream is = new DataInputStream(FileInputStream(file));
byte[] bytes = new byte[(int) file.length()];
is.readFully(bytes);
is.close();

Mit einem MappedByteBuffer ist effizienter und vermeidet eine Kopie der Daten (oder mit Hilfe der heap viel), vorausgesetzt, Sie können die ByteBuffer direkt, aber wenn Sie verwenden ein byte[] seine unwahrscheinlich viel helfen.

InformationsquelleAutor der Antwort Peter Lawrey

Dachte ich, ich könnte einfach erweitern ByteArrayOutputStream und schreiben Sie diese Methode, also zur Rückgabe des original-array direkt. Gibt es eine potenzielle Gefahr ist hier, da der stream und das byte-array nicht mehr als einmal verwendet werden?

Sollte man nicht ändern, das spezifizierte Verhalten der bestehenden Methode, aber es ist völlig in Ordnung, um eine neue Methode hinzufügen. Hier ist eine Implementierung:

/** Subclasses ByteArrayOutputStream to give access to the internal raw buffer. */
public class ByteArrayOutputStream2 extends java.io.ByteArrayOutputStream {
    public ByteArrayOutputStream2() { super(); }
    public ByteArrayOutputStream2(int size) { super(size); }

    /** Returns the internal buffer of this ByteArrayOutputStream, without copying. */
    public synchronized byte[] buf() {
        return this.buf;
    }
}

Alternative, sondern hackish Weg, um den Puffer aus alle ByteArrayOutputStream ist die Verwendung der Tatsache, dass seine writecontentto(Ausgabestrom) - Methode übergibt den Puffer direkt in den Ausgabestrom zur Verfügung gestellt:

/**
 * Returns the internal raw buffer of a ByteArrayOutputStream, without copying.
 */
public static byte[] getBuffer(ByteArrayOutputStream bout) {
    final byte[][] result = new byte[1][];
    try {
        bout.writeTo(new OutputStream() {
            @Override
            public void write(byte[] buf, int offset, int length) {
                result[0] = buf;
            }

            @Override
            public void write(int b) {}
        });
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return result[0];
}

(Das funktioniert, aber ich bin mir nicht sicher, ob es nützlich ist, gegeben, dass Unterklassen ByteArrayOutputStream ist einfacher.)

Jedoch von dem rest Ihrer Frage, es klingt wie alles, was Sie wollen ist eine einfache byte[] der komplette Inhalt der Datei. Ab Java 7, der einfachste und Schnellste Weg zu tun, der ist, rufen - Dateien.readAllBytes. In Java 6 und darunter, können Sie DataInputStream.readFully wie in Peter Lawrey Antwort. Jede Weise, erhalten Sie ein array zugewiesen wird einmal in der richtigen Größe, ohne die wiederholte Umverteilung der ByteArrayOutputStream.

InformationsquelleAutor der Antwort Boann

... kam hier mit die gleiche Beobachtung beim Lesen einer 1 GB-Datei: Oracle ByteArrayOutputStream hat ein lazy-memory-management.
Ein byte-Array wird indiziert durch eine int-und eine solche sowieso auf 2 GB beschränkt. Ohne Abhängigkeit von 3rd-party-vielleicht finden Sie diese nützlich:

static public byte[] getBinFileContent(String aFile) 
{
    try
    {
        final int bufLen = 32768;
        final long fs = new File(aFile).length();
        final long maxInt = ((long) 1 << 31) - 1;
        if (fs > maxInt)
        {
            System.err.println("file size out of range");
            return null;
        }
        final byte[] res = new byte[(int) fs];
        final byte[] buffer = new byte[bufLen];
        final InputStream is = new FileInputStream(aFile);
        int n;
        int pos = 0;
        while ((n = is.read(buffer)) > 0)
        {
            System.arraycopy(buffer, 0, res, pos, n);
            pos += n;
        }
        is.close();
        return res;
    }
    catch (final IOException e)
    {
        e.printStackTrace();
        return null;
    }
    catch (final OutOfMemoryError e)
    {
        e.printStackTrace();
        return null;
    }
}

InformationsquelleAutor der Antwort Sam Ginrich