Java liest große Dateien effizient

1. Überblick

Dieses Tutorial zeigt, wie man große Dateien effizient mit Java liest. Dieser Artikel ist Teil der Tutorialreihe „Java – Back to Basics“ auf Baeldung (http://www.baeldung.com/).

2. Im Speicher lesen

Die Standardmethode zum Lesen von Dateizeilen ist das Lesen im Speicher. Sowohl Guava als auch Apache Commons IO bieten eine schnelle Möglichkeit, Dateizeilen zu lesen, wie unten gezeigt.

Files.readLines(new File(path), Charsets.UTF_8);
 
FileUtils.readLines(new File(path));

Das Problem bei dieser Methode besteht darin, dass alle Zeilen der Datei im Speicher gespeichert werden. Wenn die Datei groß genug ist, löst das Programm bald eine OutOfMemoryError-Ausnahme aus.

Zum Beispiel: Lesen Sie eine Datei von etwa 1 GB:

@Test
public void givenUsingGuava_whenIteratingAFile_thenWorks() throws IOException {
    String path = ...
    Files.readLines(new File(path), Charsets.UTF_8);
}

Diese Methode beansprucht am Anfang nur sehr wenig Speicher: (ca. 0 MB Speicher werden verbraucht)

[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Total Memory: 128 Mb
[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Free Memory: 116 Mb

Wenn jedoch alle Dateien in den Speicher eingelesen sind, können wir endlich sehen (ungefähr 2 GB Speicher verbraucht):

[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Total Memory: 2666 Mb
[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Free Memory: 490 Mb

Das bedeutet, dass dieser Vorgang ungefähr 2,1 GB Speicher verbraucht—— Der Grund ist einfach: Jetzt werden alle Zeilen der Datei im Speicher gespeichert.

Durch das Ablegen des gesamten Inhalts einer Datei im Speicher wird der verfügbare Speicher schnell erschöpft – egal wie viel Speicher tatsächlich verfügbar ist, das ist offensichtlich.

Darüber hinaus müssen wir normalerweise nicht alle Zeilen der Datei auf einmal in den Speicher legen – stattdessen müssen wir nur jede Zeile der Datei durchlaufen, die entsprechende Verarbeitung durchführen und sie wegwerfen nach der Bearbeitung. Genau das werden wir also tun – die Zeilen durchlaufen, anstatt alle Zeilen im Speicher zu halten.

3. Dateistream

Schauen wir uns nun diese Lösung an – wir verwenden die Klasse java.util.Scanner, um den Inhalt der Datei zu scannen und sie kontinuierlich Zeile für Zeile zu lesen:

FileInputStream inputStream = null;
Scanner sc = null;
try {
    inputStream = new FileInputStream(path);
    sc = new Scanner(inputStream, "UTF-8");
    while (sc.hasNextLine()) {
        String line = sc.nextLine();
        // System.out.println(line);
    }
    // note that Scanner suppresses exceptions
    if (sc.ioException() != null) {
        throw sc.ioException();
    }
} finally {
    if (inputStream != null) {
        inputStream.close();
    }
    if (sc != null) {
        sc.close();
    }
}

Dieses Schema iteriert über alle Zeilen in der Datei – so kann jede Zeile verarbeitet werden, ohne einen Verweis darauf beizubehalten. Kurz gesagt, sie werden nicht im Speicher gespeichert: (ca. 150 MB Speicher werden verbraucht)

[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Total Memory: 763 Mb
[main] INFO  org.baeldung.java.CoreJavaIoUnitTest - Free Memory: 605 Mb

4. Apache Commons IO-Stream

Sie können auch die Commons IO-Bibliothek verwenden, um Custom bereitzustellen LineIterator:

LineIterator it = FileUtils.lineIterator(theFile, "UTF-8");
try {
    while (it.hasNext()) {
        String line = it.nextLine();
        // do something with line
    }
} finally {
    LineIterator.closeQuietly(it);
}

Da nicht die gesamte Datei im Speicher gespeichert wird, führt dies auch zu einem sehr konservativen Speicherverbrauch: (ungefähr 150 MB verbrauchter Speicher)

[main] INFO  o.b.java.CoreJavaIoIntegrationTest - Total Memory: 752 Mb
[main] INFO  o.b.java.CoreJavaIoIntegrationTest - Free Memory: 564 Mb