Overview of FileReader Class
The FileReader class extends the InputStreamReader class and is specifically designed for reading character-based data from a file. It is an ideal choice when working with text files and allows for efficient reading of characters from a file. To use the FileReader class, you need to create an instance of it and provide the file path as a parameter. This establishes a connection between the file reader object and the specified file, enabling you to read characters from it.Java FileReader Example
Let's look at an example that demonstrates how to use the FileReader class to read the contents of a file:
// We import the necessary classes: `java.io.BufferedReader`
import java.io.BufferedReader;
// We import the class: `java.io.FileReader` here to use fileReader
import java.io.FileReader;
// We import the class: `java.io.IOException` here to handle fileReader exception
import java.io.IOException;
public class FileReaderExample {
public static void main(String[] args) {
String filePath = "/path/to/example.txt";
try (FileReader fileReader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(fileReader)) {
String line;
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.out.println("Error reading file: " + e.getMessage());
}
}
}
Pseudocode explanation:
- Import the necessary classes: BufferedReader, FileReader, and IOException.
- Define a class named FileReaderExample.
- Inside the main method, we declare a String variable named filePath and assign it the absolute path to the "example.txt" file on the system.
- Use a try-with-resources statement to automatically close the FileReader and BufferedReader instances when we're done using them.
- Inside the try block, create a FileReader object, passing the filePath to its constructor.
- Create a BufferedReader object, passing the FileReader object as its argument, which allows us to read the file line by line efficiently.
- Declare a String variable named line to store each line of the file.
- Enter a loop that continues as long as the line is not null.
- Inside the loop, read a line from the file using the readLine method of the bufferedReader object.
- If the line is not null, print it to the console using System.out.println().
- If any exception occurs during file reading, catch it in the catch block and print an error message.
Output
Exploring FileReader Constructors and Their Usage
FileReader Constructors
The FileReader class provides several overloaded constructors, each useful in different situations:
FileReader(String fileName): Creates a new FileReader by opening a connection to the file specified by the given file name (a string path).
FileReader(File file): Creates a new FileReader given a File object.
FileReader(FileDescriptor fd): Creates a new FileReader using a file descriptor, usually when you’ve already opened the file via other means.
Code Examples
Let’s see them in action. We’ll read a file named example.txt in three different ways, just to illustrate how each constructor can be used.
// 1) Using a string path
import java.io.FileReader;
import java.io.IOException;
public class FileReaderStringPathExample {
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();
}
}
}
// 2) Using a File object
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderFileExample {
public static void main(String[] args) {
File file = new File("example.txt");
try (FileReader reader = new FileReader(file)) {
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 3) Using a FileDescriptor
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderFdExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("example.txt")) {
FileDescriptor fd = fis.getFD();
try (FileReader reader = new FileReader(fd)) {
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Cool, right? Each approach does the same job—reads characters from example.txt—but the constructor you choose depends on whether you have a path, a File object, or a FileDescriptor at your disposal.
The Default System Character Encoding
One important detail about FileReader: it relies on your operating system’s default character encoding. That might be fine for quick tests, but if your file is in a different encoding, you could run into garbled characters or weird question marks.
If you need more control over the character encoding, consider using InputStreamReader with a specified charset, like this:
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
try (InputStreamReader isr = new InputStreamReader(
new FileInputStream("example.txt"), StandardCharsets.UTF_8)) {
// Read data with UTF-8 decoding
}
This way, you’re not at the mercy of the system’s default encoding. This can be especially important in globalized applications or when reading files from unknown sources.
GO TO FULL VERSION