Tutorial

Java Read File: Complete Guide with Examples

Updated on February 20, 2025
Java Read File: Complete Guide with Examples

Introduction

In this article, you will learn about different ways to use Java to read the contents of a file line-by-line. This article uses methods from the following Java classes: java.io.BufferedReader, java.util.Scanner, Files.readAllLines(), and java.io.RandomAccessFile.

Reading a File Line-by-Line using BufferedReader

You can use the readLine() method from java.io.BufferedReader to read a file line-by-line to String. This method returns null when the end of the file is reached.

Here is an example program to read a file line-by-line with BufferedReader:

ReadFileLineByLineUsingBufferedReader.java
package com.journaldev.readfileslinebyline;

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

public class ReadFileLineByLineUsingBufferedReader {

 public static void main(String[] args) {
  BufferedReader reader;

  try {
   reader = new BufferedReader(new FileReader("sample.txt"));
   String line = reader.readLine();

   while (line != null) {
    System.out.println(line);
    // read next line
    line = reader.readLine();
   }

   reader.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

}

Continue your learning with the BufferedReader API Doc (Java SE 8).

Reading a File Line-by-Line using Scanner

You can use the Scanner class to open a file and then read its content line-by-line.

Here is an example program to read a file line-by-line with Scanner:

ReadFileLineByLineUsingScanner.java
package com.journaldev.readfileslinebyline;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadFileLineByLineUsingScanner {

 public static void main(String[] args) {
  try {
   Scanner scanner = new Scanner(new File("sample.txt"));

   while (scanner.hasNextLine()) {
    System.out.println(scanner.nextLine());
   }

   scanner.close();
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  }
 }

}

Continue your learning with the Scanner API Doc (Java SE 8).

Reading a File Line-by-Line using Files

java.nio.file.Files is a utility class that contains various useful methods. The readAllLines() method can be used to read all the file lines into a list of strings.

Here is an example program to read a file line-by-line with Files:

ReadFileLineByLineUsingFiles.java
package com.journaldev.readfileslinebyline;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class ReadFileLineByLineUsingFiles {

 public static void main(String[] args) {
  try {
   List<String> allLines = Files.readAllLines(Paths.get("sample.txt"));

   for (String line : allLines) {
    System.out.println(line);
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

}

Continue your learning with the Files API Doc (Java SE 8).

Reading a File Line-by-Line using RandomAccessFile

You can use RandomAccessFile to open a file in read mode and then use its readLine method to read a file line-by-line.

Here is an example program to read a file line-by-line with RandomAccessFile:

ReadFileLineByLineUsingRandomAccessFile.java
package com.journaldev.readfileslinebyline;

import java.io.IOException;
import java.io.RandomAccessFile;

public class ReadFileLineByLineUsingRandomAccessFile {

 public static void main(String[] args) {
  try {
   RandomAccessFile file = new RandomAccessFile("sample.txt", "r");
   String str;

   while ((str = file.readLine()) != null) {
    System.out.println(str);
   }

   file.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

}

Continue your learning with the RandomAccessFile API Doc (Java SE 8).

Handling Different Encodings in Java File Reading

If a file is stored in an encoding other than UTF-8, you should specify the correct encoding when reading it.

Reading a File with UTF-8 Encoding

import java.nio.charset.StandardCharsets;
import java.nio.file.*;

public class ReadUTF8File {
    public static void main(String[] args) {
        try {
            // This line reads the content of the file "example.txt" assuming it's encoded in UTF-8.
            // The Path.of("example.txt") method creates a Path object representing the file path.
            // The StandardCharsets.UTF_8 parameter specifies the character set to use for decoding.
            String content = Files.readString(Path.of("example.txt"), StandardCharsets.UTF_8);
            // This line prints the content of the file to the console.
            System.out.println(content);
        } catch (IOException e) {
            // This block catches any IOException that might occur during file reading and prints the stack trace.
            e.printStackTrace();
        }
    }
}

Reading a File with UTF-16 Encoding

import java.nio.charset.Charset;
import java.nio.file.*;

public class ReadUTF16File {
    public static void main(String[] args) {
        try {
            // This line reads the content of the file "example.txt" assuming it's encoded in UTF-16.
            // The Path.of("example.txt") method creates a Path object representing the file path.
            // The Charset.forName("UTF-16") parameter specifies the character set to use for decoding.
            String content = Files.readString(Path.of("example.txt"), Charset.forName("UTF-16"));
            // This line prints the content of the file to the console.
            System.out.println(content);
        } catch (IOException e) {
            // This block catches any IOException that might occur during file reading and prints the stack trace.
            e.printStackTrace();
        }
    }
}

Efficiently Handling Large Files Using Streams or FileChannel

For massive files (GB-sized logs or datasets), Java’s NIO API (FileChannel) is a high-performance alternative to standard file reading.

Here is an example:

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.*;

public class FileChannelExample {
    public static void main(String[] args) {
        try (FileChannel fileChannel = FileChannel.open(Path.of("largefile.txt"), StandardOpenOption.READ)) {
            // Allocate a ByteBuffer with a capacity of 4096 bytes to read data from the file channel.
            ByteBuffer buffer = ByteBuffer.allocate(4096);
            // Continuously read data from the file channel into the buffer until there is no more data to read.
            while (fileChannel.read(buffer) > 0) {
                // Flip the buffer to prepare it for reading. This sets the limit to the current position and the position to 0.
                buffer.flip();
                // Convert the buffer's content to a string and print it to the console. The parameters specify the start index, end index, and the character set.
                System.out.print(new String(buffer.array(), 0, buffer.limit()));
                // Clear the buffer to prepare it for the next read operation. This sets the position to 0 and the limit to the capacity.
                buffer.clear();
            }
        } catch (IOException e) {
            // Catch any IOException that might occur during file reading and print the stack trace.
            e.printStackTrace();
        }
    }
}

Using FileChannel significantly reduces memory usage compared to loading a file into memory at once.

For more advanced file handling techniques, you can check out this tutorial on Java Files - java.nio.file.Files Class.

FAQs

1. How to read a file in Java using FileReader?

To read a file in Java using FileReader, you can create an instance of FileReader and read character data from the file. However, FileReader is not the most efficient option as it does not buffer the input. A better alternative is to wrap it inside a BufferedReader.

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

public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

For more efficient file reading, consider using BufferedReader instead.

2. How to read a file line by line in Java?

The most common way to read a file line by line in Java is by using BufferedReader. This method is memory-efficient and performs well for large files.

Example using BufferedReader:

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

public class ReadFileLineByLine {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

For additional file handling methods, check out this tutorial on Java File Handling.

3. What is the most efficient way to read a large file in Java?

When dealing with large files, reading the entire file into memory is inefficient. Instead, use streams or Java NIO (Non-blocking I/O) APIs like FileChannel for better performance.

Using BufferedReader with Streams (Efficient for Large Files)

import java.io.*;
import java.nio.file.*;

public class LargeFileReader {
    public static void main(String[] args) {
        try (BufferedReader reader = Files.newBufferedReader(Path.of("largefile.txt"))) {
            reader.lines().forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Using FileChannel (Best for Extremely Large Files)

For extremely large files, consider memory-mapped files or FileChannel for improved performance as described in the section above.

4. How to handle file reading errors in Java?

Error handling is crucial to avoid crashes due to file not found, permissions issues, or encoding mismatches.

  • Use try-with-resources to automatically close file resources.
  • Check file existence using Files.exists(Path.of("file.txt")).
  • Catch exceptions like IOException to handle errors gracefully.
import java.io.*;

public class FileErrorHandling {
    public static void main(String[] args) {
        File file = new File("nonexistent.txt");

        if (!file.exists()) {
            System.out.println("File does not exist!");
            return;
        }

        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            System.out.println(reader.readLine());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

5. What is the difference between FileReader and BufferedReader?

Feature FileReader BufferedReader
Performance Reads one character at a time Reads a full buffer (default 8192 bytes) at a time
Use case Small files, simple character-based reading Efficient reading, best for large files
Efficiency Less efficient Highly efficient

To handle large text files efficiently, always prefer BufferedReader over FileReader. Learn more about efficient file operations in tutorial on Java read text file.

Conclusion

In this comprehensive guide, you learned various methods to read the contents of a file line-by-line in Java, including the use of BufferedReader, Scanner, Files.readAllLines(), and RandomAccessFile. You also learned how to handle file reading errors, the difference between FileReader and BufferedReader, and how to efficiently handle large files using FileChannel or memory-mapped files.

Continue your learning with more Java tutorials.

You can also refer to these tutorials on:

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

About the author(s)

Category:
Tutorial
Tags:

Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?
 
JournalDev
DigitalOcean Employee
DigitalOcean Employee badge
February 6, 2013

Looks very good. Would you be so kind to give an example on how to read random lines from a file?

- Vulco Viljoen

    JournalDev
    DigitalOcean Employee
    DigitalOcean Employee badge
    December 17, 2014

    Hello I have to create java program in such a way that output should be print on thermal printer for which paper size ,font size etc should be modified with text file ( template )…I have created program which read normal file and print but how to handle paper size anf font size things pls help me out there

    - Rinku

      JournalDev
      DigitalOcean Employee
      DigitalOcean Employee badge
      February 13, 2019

      I want to create a java program to read input from text file but don’t want to read all the lines at once,Instead I want my Java program to read Input as in when required line by line. need help… Thanks a lot , for giving a shot to my query.

      - Dinesh

        JournalDev
        DigitalOcean Employee
        DigitalOcean Employee badge
        April 9, 2019

        Thanks for your tutorials. Is there a way to grab each individual line and assign it to a variable? Somthing like String line [ i } = reader.readLine(); String line1 = line[ o ]; String line2 = line [1 ]; and so on. I tried this and I get the first line on the first line1 string with the rest as nulls. Then i get the first and second line with the rest as nulls on line2 string.

        - Bill Melendez

          JournalDev
          DigitalOcean Employee
          DigitalOcean Employee badge
          November 12, 2019

          I write a file handling program, I read data from file. In a file a create a table(name,age,clg) when I read data,I get data with column name but I want only data nat file name please suggest me how can do

          - Sp

            JournalDev
            DigitalOcean Employee
            DigitalOcean Employee badge
            May 29, 2020

            Is there a way to read a specific line from a file without first reading all previous lines if you know the line length? I’m seeking something analogous to the BASIC code OPEN FILE$ AS 1 LEN = 5 READ #1, 5, LINE% READ #1, LINE%, DESC$

            - Jeff Mullen

              JournalDev
              DigitalOcean Employee
              DigitalOcean Employee badge
              November 9, 2020

              SO what im trying to do is reading each line from a file (named fileName) and writing it into a new file (named fileName2), so basically a copier. How would you do that?

              - Ana Pathak

                Try DigitalOcean for free

                Click below to sign up and get $200 of credit to try our products over 60 days!

                Sign up

                Join the Tech Talk
                Success! Thank you! Please check your email for further details.

                Please complete your information!

                Become a contributor for community

                Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

                DigitalOcean Documentation

                Full documentation for every DigitalOcean product.

                Resources for startups and SMBs

                The Wave has everything you need to know about building a business, from raising funding to marketing your product.

                Get our newsletter

                Stay up to date by signing up for DigitalOcean’s Infrastructure as a Newsletter.

                New accounts only. By submitting your email you agree to our Privacy Policy

                The developer cloud

                Scale up as you grow — whether you're running one virtual machine or ten thousand.

                Get started for free

                Sign up and get $200 in credit for your first 60 days with DigitalOcean.*

                *This promotional offer applies to new accounts only.