Difference Between FileReader and BufferedReader in Java

1. Overview

FileReader and BufferedReader are two classes that can read characters from an input stream.

In this tutorial, we’ll see the differences between them.

2. FileReader

The FileReader class can read streams of characters from a file. Moreover, it’s only able to read the file character by character, and every time we call its read() method, it directly accesses the file on the hard drive to read exactly one character from it. As a result, FileReader is very slow and inefficient in and of itself when reading characters from files. In addition, FileReader can only read characters from files and no other type of input stream.

2.1. Constructors

FileReader has three constructors:

• FileReader(File file): receives a File instance as an argument
• FileReader(FileDescriptor fd): receives a FileDescriptor as an argument
• FileReader(String fileName): receives the filename (including its path) as an argument

2.2. What It Returns

Every time we call the read() method, it returns an integer value representing the Unicode value for the character that was read from the file or -1 if the end of the character stream is reached.

2.3. Example

Let’s see an example of using FileReader to read characters from a text file that contains “qwerty” as content:

@Test
public void whenReadingAFile_thenReadsCharByChar() {
    StringBuilder result = new StringBuilder();

    try (FileReader fr = new FileReader("src/test/resources/sampleText2.txt")) {
        int i = fr.read();

        while(i != -1) {
            result.append((char)i);

            i = fr.read();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    assertEquals("qwerty", result.toString());
}

In the above code, we cast the return value from the read() method to char before appending it to the result string.

3. BufferedReader

The BufferedReader class creates a buffer to hold data from the character input stream. Moreover, the input stream can be a file, the console, a string, or any other type of character stream.

Its constructor receives a Reader as the character input stream. Therefore, we can give any class that implements the Reader abstract class to BufferedReader as the input stream to read characters from.

When we start reading from a BufferedReader, it reads an entire data block from the input stream and stores it in a buffer. After that, if we continue reading from the BufferedReader, it returns the characters from the buffer instead of the underlying character stream until the buffer is empty. It’ll then read another data block from the input stream and store it in the buffer for further read calls.

The BufferedReader class reduces the read operations called on the input stream, and reading from a buffer is generally much faster than accessing the underlying input stream. Therefore, BufferedReader provides a faster, more efficient way of reading characters from a character stream.

3.1. Constructors

BufferedReader has two constructors:

• BufferedReader(Reader in): receives the character input stream (which must implement the Reader abstract class) as an argument
• BufferedReader(Reader in, int sz): receives the character input stream and the buffer size as arguments

3.2. What It Returns

If we call the read() method, it returns an int value, the Unicode value for the character that was read from the input stream. Moreover, if we call the readLine() method, it reads an entire line from the buffer and returns it as a string value.

3.3. Example

Let’s use BufferedReader to read characters from a text file with three lines of content using an implementation of InputStreamReader which is more efficient:

@Test
public void whenReadingAFile_thenReadsLineByLine() {
    StringBuilder result = new StringBuilder();
    
    final Path filePath = new File("src/test/resources/sampleText1.txt").toPath();
    try (BufferedReader br = new BufferedReader(new InputStreamReader(Files.newInputStream(filePath), StandardCharsets.UTF_8))) {
        String line;

        while((line = br.readLine()) != null) {
            result.append(line);
            result.append('\n');
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    assertEquals("first line\nsecond line\nthird line\n", result.toString());
}

The above test code passes, which means BufferedReader successfully reads all three lines of text from the file.

4. What Is the Difference?

BufferedReader is much faster and more efficient than FileReader since it reads an entire data block from the input stream and holds it in a buffer for further read calls, while FileReader needs to access the file for every character. Moreover, FileReader can only read a file character by character, while BufferedReader has other methods like readLine(), which reads an entire line from the buffer. Finally, FileReader can only read from a file, while BufferedReader can read from any type of character input stream (file, console, string, and so on):

FileReader can be enough if we’re reading from small files and when there are few read calls on the file data. However, for large files or when there are many read operations on the data, BufferedReader is the better option.

5. Summary

In this tutorial, we learned how to use FileReader and BufferedReader and the differences between them.