What's the Most Efficient Way to Count Lines in a Java File?

How to Efficiently Determine the Number of Lines in a Java File

Counting the number of lines in a file is a common task in programming. In Java, one common approach is to read the file line by line until reaching the end, which can be inefficient for large files.

A more optimized solution is to use the countLinesOld method, which reads the file byte by byte and counts the occurrences of the newline character (n). This approach is significantly faster than reading the file line by line, especially for large files.

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

However, for even faster performance, consider using the countLinesNew method, which leverages optimizations such as unrolling the loop and caching the line count for each 1024-byte chunk of the file.

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

These optimized methods provide substantial speed improvements over the standard readLines approach, making them ideal for counting lines in large files efficiently.

The above is the detailed content of What's the Most Efficient Way to Count Lines in a Java File?. For more information, please follow other related articles on the PHP Chinese website!