How to Read a Large File Line by Line in Java

When a file is very large, loading the whole thing into memory can slow your program down or even cause memory issues. A better approach is to read a large file line by line in Java efficiently so your application only handles one line at a time. This is simple, memory-friendly, and works well for logs, CSV files, and text exports.

Why read line by line?

If you use methods that read the entire file at once, Java has to keep all of that content in memory. For small files, that is fine. For large files, it is wasteful.

Reading line by line gives you a few benefits:

• Lower memory usage
• Better performance for large text files
• Easier processing of each line as it arrives

Best option: BufferedReader

The most common and efficient way is to use BufferedReader. It reads text in chunks behind the scenes, which reduces expensive disk access.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LargeFileReader {
    public static void main(String[] args) {
        String filePath = "largefile.txt";

        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class LargeFileReader {
    public static void main(String[] args) {
        String filePath = "largefile.txt";

        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

How this works

• FileReader opens the file
• BufferedReader wraps it for faster reading
• readLine() gets one line at a time
• The try-with-resources block closes the file automatically

This is one of the easiest ways to read a large file line by line in Java efficiently without making the code complicated.

Better modern option: Files.newBufferedReader

A more modern approach uses the Files class from java.nio.file.

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class LargeFileReaderNio {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");

        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class LargeFileReaderNio {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");

        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;

            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This version is often preferred in modern Java because it works well with the Path API.

When to use Files.lines()

You can also process lines as a stream:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class LargeFileReaderStream {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");

        try (var lines = Files.lines(path)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class LargeFileReaderStream {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");

        try (var lines = Files.lines(path)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This is clean and useful, but for very large files, a plain BufferedReader loop is often easier to control, especially if you need custom logic, error handling, or counters.

Simple tip for performance

If you are only processing the file, avoid storing all lines in a list unless you really need them later. Print them, parse them, or save results as you go.

Example with a line counter:

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class CountLines {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");
        int count = 0;

        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;

            while ((line = reader.readLine()) != null) {
                count++;
                // process line here
            }

            System.out.println("Total lines: " + count);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class CountLines {
    public static void main(String[] args) {
        Path path = Path.of("largefile.txt");
        int count = 0;

        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;

            while ((line = reader.readLine()) != null) {
                count++;
                // process line here
            }

            System.out.println("Total lines: " + count);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

To handle large text files well, the safest approach is to use BufferedReader or Files.newBufferedReader and process one line at a time. That is the simplest way to read a large file line by line in Java efficiently while keeping memory usage low and code easy to maintain.