TOC

Comment lire efficacement un fichier volumineux avec Java

Comment lire efficacement un fichier volumineux avec Java

1. Vue d'ensemble

Ce tutoriel montrerahow to read all the lines from a large file in Java de manière efficace.

Cet article fait partie dethe “Java – Back to Basic” tutorial ici par exemple.

Lectures complémentaires:

Java - Écrire un InputStream dans un fichier

Comment écrire un InputStream dans un fichier - en utilisant Java, Guava et la bibliothèque Commons IO.

Read more →

Java - Convertir un fichier en InputStream

Comment ouvrir un InputStream à partir d'un fichier Java - à l'aide de Java pur, de Guava et de la bibliothèque Apache Commons IO.

Read more →

Java - Lecture à partir d'un fichier

Lire le contenu d'un fichier en Java - en utilisant l'un de ces éléments: BufferedReader, Scanner, StreamTokenizer, DataInputStream, SequenceInputStream, FileChannel, etc.

Read more →

2. Lecture en mémoire

La manière standard de lire les lignes du fichier est en mémoire - Guava et Apache Commons IO fournissent un moyen rapide de le faire: 

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

Le problème avec cette approche est que toutes les lignes de fichier sont conservées en mémoire - ce qui conduira rapidement àOutOfMemoryError si le fichier est suffisamment grand.

Par exemple -reading a ~1Gb file: 

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

Cela commence par une petite quantité de mémoire consommée:(~0 Mb consumed) 

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

Cependant,after the full file has been processed, nous avons à la fin:(~2 Gb consumed) 

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

Ce qui signifie qu'environ 2,1 Go de mémoire sont utilisés par le processus - la raison en est simple - les lignes du fichier sont toutes stockées en mémoire.

Il devrait être évident à ce stade quekeeping in memory the contents of the file will quickly exhaust the available memory - quel que soit le montant réel.

De plus,we usually don’t need all of the lines in the file in memory at once - au lieu de cela, nous devons simplement pouvoir parcourir chacun d’entre eux, effectuer un traitement et le jeter. Donc, c’est exactement ce que nous allons faire: parcourir les lignes sans les garder en mémoire.

3. Diffusion dans le fichier

Examinons maintenant une solution - nous allons utiliser unjava.util.Scanner pour parcourir le contenu du fichier et récupérer les lignes en série, une par une: 

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

Cette solution va parcourir toutes les lignes du fichier - permettant le traitement de chaque ligne - sans en garder les références - et en conclusion,without keeping them in memory:(~150 Mb consumed) 

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

4. Streaming avec Apache Commons IO

La même chose peut être obtenue en utilisant la bibliothèque Commons IO également, en utilisantthe custom LineIterator fourni par la bibliothèque: 

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

Étant donné que le fichier entier n'est pas entièrement en mémoire, cela entraînera égalementpretty conservative memory consumption numbers:(~150 Mb consumed) 

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

5. Conclusion

Cet article rapide montre commentprocess lines in a large file without iteratively, without exhausting the available memory - ce qui s'avère très utile lorsque vous travaillez avec ces gros fichiers.

L'implémentation de tous ces exemples et extraits de codecan be found in our GitHub project - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.

Related