Nombre de lignes dans un fichier en Java

Question

J'utilise d'énormes fichiers de données, parfois je n'ai besoin que du nombre de lignes dans ces fichiers, généralement je les ouvre et les lis ligne par ligne jusqu'à ce que j'atteigne la fin du fichier.

Je me demandais s'il existait une manière plus intelligente de procéder.

Answer 1

C'est la version la plus rapide que j'ai trouvée jusqu'à présent, environ 6 fois plus rapide que readLines. Sur un fichier journal de 150 Mo, cela prend 0,35 seconde, contre 2,40 secondes en utilisant readLines(). Pour l'anecdote, la commande wc -l de linux prend 0,15 seconde.

public static int countLinesOld(String filename) throws IOException {
    InputStream is = new BufferedInputStream(new FileInputStream(filename));
    try {
        byte[] c = new byte[1024];
        int count = 0;
        int readChars = 0;
        boolean empty = true;
        while ((readChars = is.read(c)) != -1) {
            empty = false;
            for (int i = 0; i < readChars; ++i) {
                if (c[i] == '\n') {
                    ++count;
                }
            }
        }
        return (count == 0 && !empty) ? 1 : count;
    } finally {
        is.close();
    }
}

EDIT, 9 ans et demi plus tard : Je n'ai pratiquement aucune expérience en Java, mais j'ai tout de même essayé de comparer ce code à la norme LineNumberReader solution ci-dessous car cela me dérangeait que personne ne l'ait fait. Il semble que ma solution soit plus rapide, surtout pour les gros fichiers. Bien qu'il faille quelques exécutions avant que l'optimiseur ne fasse un travail décent. J'ai joué un peu avec le code, et j'ai produit une nouvelle version qui est toujours la plus rapide :

public static int countLinesNew(String filename) throws IOException {
    InputStream is = new BufferedInputStream(new FileInputStream(filename));
    try {
        byte[] c = new byte[1024];

        int readChars = is.read(c);
        if (readChars == -1) {
            // bail out if nothing to read
            return 0;
        }

        // make it easy for the optimizer to tune this loop
        int count = 0;
        while (readChars == 1024) {
            for (int i=0; i<1024;) {
                if (c[i++] == '\n') {
                    ++count;
                }
            }
            readChars = is.read(c);
        }

        // count remaining characters
        while (readChars != -1) {
            for (int i=0; i<readChars; ++i) {
                if (c[i] == '\n') {
                    ++count;
                }
            }
            readChars = is.read(c);
        }

        return count == 0 ? 1 : count;
    } finally {
        is.close();
    }
}

Résultats du benchmark pour un fichier texte de 1.3GB, axe y en secondes. J'ai effectué 100 exécutions avec le même fichier, et j'ai mesuré chaque exécution avec System.nanoTime() . Vous pouvez constater que countLinesOld comporte quelques valeurs aberrantes, et countLinesNew n'en a pas et, bien qu'il ne soit que légèrement plus rapide, la différence est statistiquement significative. LineNumberReader est nettement plus lent.

Answer 2

J'ai mis en œuvre une autre solution au problème, je l'ai trouvée plus efficace pour compter les rangées :

try
(
   FileReader       input = new FileReader("input.txt");
   LineNumberReader count = new LineNumberReader(input);
)
{
   while (count.skip(Long.MAX_VALUE) > 0)
   {
      // Loop just in case the file is > Long.MAX_VALUE or skip() decides to not read the entire file
   }

   result = count.getLineNumber() + 1;                                    // +1 because line index starts at 0
}

Answer 3

La réponse acceptée comporte une erreur de décalage pour les fichiers multilignes qui ne se terminent pas par une nouvelle ligne. Un fichier d'une ligne se terminant sans nouvelle ligne renverrait 1, mais un fichier de deux lignes se terminant sans nouvelle ligne renverrait également 1. Voici une implémentation de la solution acceptée qui corrige ce problème. Les vérifications de endsWithoutNewLine sont inutiles pour tout ce qui n'est pas la lecture finale, mais devraient être triviales en termes de temps par rapport à l'ensemble de la fonction.

public int count(String filename) throws IOException {
    InputStream is = new BufferedInputStream(new FileInputStream(filename));
    try {
        byte[] c = new byte[1024];
        int count = 0;
        int readChars = 0;
        boolean endsWithoutNewLine = false;
        while ((readChars = is.read(c)) != -1) {
            for (int i = 0; i < readChars; ++i) {
                if (c[i] == '\n')
                    ++count;
            }
            endsWithoutNewLine = (c[readChars - 1] != '\n');
        }
        if(endsWithoutNewLine) {
            ++count;
        } 
        return count;
    } finally {
        is.close();
    }
}

Answer 4

Con java-8 vous pouvez utiliser les flux :

try (Stream<String> lines = Files.lines(path, Charset.defaultCharset())) {
  long numOfLines = lines.count();
  ...
}

Answer 5

La réponse avec la méthode count() ci-dessus me donnait des erreurs de comptage de lignes si un fichier n'avait pas de nouvelle ligne à la fin du fichier - il ne comptait pas la dernière ligne du fichier.

Cette méthode me convient mieux :

public int countLines(String filename) throws IOException {
    LineNumberReader reader  = new LineNumberReader(new FileReader(filename));
int cnt = 0;
String lineRead = "";
while ((lineRead = reader.readLine()) != null) {}

cnt = reader.getLineNumber(); 
reader.close();
return cnt;
}