Lire des fichiers volumineux en Java

Question

J'ai besoin de l'avis de quelqu'un qui connaît très bien Java et les problèmes de mémoire. J'ai un gros fichier (environ 1,5 Go) et je dois le découper en plusieurs fichiers plus petits (100 petits fichiers par exemple).

Je sais généralement comment le faire (en utilisant une BufferedReader ), mais j'aimerais savoir si vous avez des conseils concernant la mémoire, ou des astuces pour le faire plus rapidement.

Mon fichier contient du texte, il n'est pas binaire et j'ai environ 20 caractères par ligne.

Answer 1

Pour économiser de la mémoire, ne stockez pas/ne dupliquez pas inutilement les données en mémoire (c'est-à-dire ne les affectez pas à des variables en dehors de la boucle). Traitez simplement la sortie immédiatement dès que l'entrée se fait.

Cela n'a vraiment aucune importance que vous utilisiez BufferedReader ou pas. Cela ne coûtera pas beaucoup plus de mémoire comme certains semblent le suggérer implicitement. Au mieux, cela n'affectera que quelques % des performances. Il en va de même pour l'utilisation de NIO. Elle n'améliorera que l'évolutivité, pas l'utilisation de la mémoire. Cela ne deviendra intéressant que lorsque des centaines de threads fonctionneront sur le même fichier.

Il suffit de parcourir le fichier en boucle, d'écrire chaque ligne immédiatement dans l'autre fichier au fur et à mesure de la lecture, de compter les lignes et s'il atteint 100, de passer au fichier suivant, et ainsi de suite.

Exemple de coup d'envoi :

String encoding = "UTF-8";
int maxlines = 100;
BufferedReader reader = null;
BufferedWriter writer = null;

try {
    reader = new BufferedReader(new InputStreamReader(new FileInputStream("/bigfile.txt"), encoding));
    int count = 0;
    for (String line; (line = reader.readLine()) != null;) {
        if (count++ % maxlines == 0) {
            close(writer);
            writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/smallfile" + (count / maxlines) + ".txt"), encoding));
        }
        writer.write(line);
        writer.newLine();
    }
} finally {
    close(writer);
    close(reader);
}

Answer 2

Tout d'abord, si votre fichier contient des données binaires, alors l'utilisation de la fonction BufferedReader serait une grave erreur (car vous convertiriez les données en String, ce qui n'est pas nécessaire et pourrait facilement corrompre les données) ; vous devriez utiliser un fichier BufferedInputStream à la place. S'il s'agit de données de type texte et que vous devez les diviser le long de sauts de ligne, vous pouvez alors utiliser BufferedReader est OK (en supposant que le fichier contient des lignes d'une longueur raisonnable).

En ce qui concerne la mémoire, il ne devrait pas y avoir de problème si vous utilisez un tampon de taille décente (j'utiliserais au moins 1 Mo pour m'assurer que le disque dur effectue principalement des lectures et des écritures séquentielles).

Si la vitesse s'avère être un problème, vous pouvez jeter un coup d'œil à l'interface de l'entreprise. java.nio Ces paquets sont censés être plus rapides que java.io ,

Answer 3

Vous pouvez envisager d'utiliser des fichiers mappés en mémoire, via Canal de fichiers s .

Généralement beaucoup plus rapide pour les gros fichiers. Il existe des compromis en matière de performances qui pourrait le rendre plus lent, donc YMMV.

Réponse connexe : Performances / utilité de Java NIO FileChannel par rapport à FileOutputstream

Answer 4

C'est un très bon article : http://java.sun.com/developer/technicalArticles/Programming/PerfTuning/

En résumé, pour obtenir de bonnes performances, vous devez :

1. Évitez d'accéder au disque.
2. Évitez d'accéder au système d'exploitation sous-jacent.
3. Évitez les appels de méthode.
4. Évitez de traiter les octets et les caractères individuellement.

Par exemple, pour réduire l'accès au disque, vous pouvez utiliser une grande mémoire tampon. L'article décrit différentes approches.

Answer 5

Faut-il le faire en Java ? En d'autres termes, doit-il être indépendant de la plate-forme ? Si ce n'est pas le cas, je vous suggère d'utiliser l'option ' divisé dans *nix. Si vous le voulez vraiment, vous pouvez exécuter cette commande via votre programme Java. Bien que je n'aie pas testé, j'imagine qu'elle est plus rapide que n'importe quelle implémentation Java IO que vous pourriez trouver.