How to Read a File in Java: A Comprehensive Tutorial

In this Tutorial, we will learn about how to read a file in Java. File manipulation is a fundamental aspect of programming, especially when dealing with data processing and storage. Java provides robust libraries and classes to handle file operations efficiently. In this in-depth tutorial, we will explore the various techniques and best practices for reading files in Java.

Understanding File Processing in Java

Before delving into file reading techniques, it’s crucial to understand the basics of file processing in Java. Files are represented by the class, which encapsulates the path to a file or directory. Java offers multiple classes like FileReader, BufferedReader, and Scanner to facilitate reading operations.

Reading Text Files Using FileReader and BufferedReader

Using FileReader and BufferedReader Classes

The FileReader class is used for reading character files. It works at the byte level, reading streams of characters. BufferedReader class, on the other hand, reads text from a character-input stream, buffering characters to provide efficient reading.


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

In this example, we read a text file line by line using FileReader wrapped in a BufferedReader.

Reading CSV Files Using Scanner Class

CSV files are widely used for storing tabular data. Java’s Scanner class simplifies the process of reading from various sources, including files. Let’s see how we can read data from a CSV file.

Reading CSV File Using Scanner

import java.util.Scanner;

public class CSVFileReader {
    public static void main(String[] args) {
        String filePath = "data.csv";

        try (Scanner scanner = new Scanner(new File(filePath))) {

            while (scanner.hasNext()) {
                System.out.print( + " ");
        } catch (FileNotFoundException e) {

In this example, the Scanner reads the CSV file and separates values using a comma (,).

Best Practices and Error Handling

Handling Exceptions

When dealing with file operations, exceptions such as FileNotFoundException and IOException must be handled properly to ensure graceful error recovery and prevent application crashes.

Using Try-With-Resources

Java 7 introduced the try-with-resources statement, which ensures that each resource is closed at the end of the statement. It simplifies resource management and reduces the chance of resource leaks and related issues.

try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
    // Read file content here
} catch (IOException e) {


In this extensive tutorial, we explored various techniques for reading files in Java, ranging from basic text files to more complex CSV files. Understanding the classes and methods provided by Java’s I/O packages is essential for effective file processing.

Remember to handle exceptions diligently and use try-with-resources to manage resources efficiently. With the knowledge gained from this tutorial, you can confidently read and manipulate files in your Java applications, ensuring smooth and reliable data processing.

By incorporating these practices and techniques into your Java projects, you are well-equipped to handle a wide array of file-reading scenarios, making your applications more versatile and robust. If you face any problem to read a file using java programming then you can search for Java assignment help. Happy coding

How do I evaluate or execute a script file?

This example demonstrated how to evaluate script that stored on a file. As we know that the eval() method can also accept a Reader object we can then read the script file using FileReader and pass it as the parameter to the eval() method of the ScriptEngine for further evaluation.

package org.kodejava.script;

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class EvalScriptFile {
    public static void main(String[] args) {
        // Obtaining ECMAScript / JavaScript ScriptEngine.
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("ECMAScript");

        try {
            // Create an instance of File object that point to our
            // scripting file. An create a FileReader to read the
            // file to be passed to the ScriptEngine.eval() method.
            // The file need to be placed in the same folder with
            // our class so it enable to read it. We can define the
            // full path to the file also to make easier for the
            // Reader to find it.
            File script = new File("helloworld.js");
            Reader reader = new FileReader(script);

        } catch (FileNotFoundException | ScriptException e) {

Our helloworld.js file.

console.log('Hello World');

for (let i = 0; i <= 10; i++) {
    console.log(`i = ${i}`);

The output of the code snippet:

Hello World
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10

Maven Dependencies


Maven Central Maven Central

How do I use LineNumberReader class to read file?

In this example we use LineNumberReader class to read file contents. What we try to do here is to get the line number of the read data. Instead of introducing another variable; an integer for instance; to keep track the line number we can utilize the LineNumberReader class. This class offers the getLineNumber() method to know the current line of the data that is read.


import java.util.Objects;

public class LineNumberReaderExample {
    public static void main(String[] args) throws Exception {
        // We'll read a file called student.csv that contains our
        // student information data.
        String filename = Objects.requireNonNull(Thread.currentThread().getContextClassLoader()

        // To create the FileReader we can pass in our student data
        // file to the reader. Next we pass the reader into our
        // LineNumberReader class.
        try (FileReader fileReader = new FileReader(filename);
             LineNumberReader lineNumberReader = new LineNumberReader(fileReader)) {
            // If we set the line number of the LineNumberReader here
            // we'll got the line number start from the defined line
            // number + 1


            String line;
            while ((line = lineNumberReader.readLine()) != null) {
                // We print out the student data and show what line
                // is currently read by our program.
                System.out.printf("Line Number %s: %s%n", lineNumberReader.getLineNumber(), line);

The /resources/student.csv file:

Alice, 7
Bob, 8
Carol, 5
Doe, 6
Earl, 6
Malory, 8

And here is the result of our code snippet above:

Line Number 1: Alice, 7
Line Number 2: Bob, 8
Line Number 3: Carol, 5
Line Number 4: Doe, 6
Line Number 5: Earl, 6
Line Number 6: Malory, 8