Read files in Java 10 ways
How to Read a File in Java Using BufferedReader and FileReader for Text Files
Code Example:
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: BufferedReader with FileReader is a common way to read text files. FileReader reads characters from the file, and BufferedReader buffers those characters for efficient line-by-line reading.
Advantages: Efficient for reading text line by line; simple and compatible with older Java versions.
Disadvantages: Less suited for binary files; manual encoding handling if not UTF-8.
Java File Reading: Using InputStreamReader and FileInputStream with Encoding Support
Code Example:
try (FileInputStream fis = new FileInputStream("file.txt");
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: FileInputStream reads bytes from a file, and InputStreamReader converts them to characters. This allows specifying a character encoding like UTF-8.
Advantages: Supports specific encoding; suitable for both text and binary files.
Disadvantages: Slightly complex; less efficient for large files.
How to Read All Lines of a File in Java Using Files.readAllLines
Code Example:
try {
List<String> lines = Files.readAllLines(Paths.get("file.txt"));
lines.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
Explanation: Files.readAllLines reads all lines at once, returning them as a List<String>.
Advantages: Easy to use; returns a list of all lines.
Disadvantages: Not efficient for large files as it loads everything into memory.
Using Files.lines in Java for Stream-Based File Reading
Code Example:
try (Stream<String> stream = Files.lines(Paths.get("file.txt"))) {
stream.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
Explanation: Files.lines provides a Stream<String> that allows processing lines using functional programming.
Advantages: Stream-based, memory-efficient for large files.
Disadvantages: Requires Java Streams knowledge; slower for smaller files.
Reading Files in Java Using Scanner for Flexible Data Handling
Code Example:
try (Scanner scanner = new Scanner(new File("file.txt"))) {
while (scanner.hasNextLine()) {
System.out.println(scanner.nextLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
Explanation: Scanner reads files line by line, word by word, or token by token, making it versatile.
Advantages: Flexible; supports pattern matching.
Disadvantages: Slower for large files; mainly for text files.
FileChannel and ByteBuffer: Efficient Java File Reading for Large and Binary Files
Code Example:
try (FileChannel channel = FileChannel.open(Paths.get("file.txt"))) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (channel.read(buffer) > 0) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: FileChannel with ByteBuffer reads data into a buffer, ideal for large files or binary data.
Advantages: Efficient for large/binary files.
Disadvantages: Complex for beginners; not ideal for small text files.
Reading Binary Data Files in Java with DataInputStream
Code Example:
try (DataInputStream dis = new DataInputStream(new FileInputStream("file.txt"))) {
while (dis.available() > 0) {
System.out.print((char) dis.readByte());
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: DataInputStream reads binary data, supporting primitive data types.
Advantages: Ideal for binary files; handles primitives.
Disadvantages: Not suited for text; no encoding support.
RandomAccessFile in Java: Read Files from Any Position
Code Example:
try (RandomAccessFile raf = new RandomAccessFile("file.txt", "r")) {
String line;
while ((line = raf.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: RandomAccessFile allows access to specific positions in a file, making it useful for large files when you only need specific parts.
Advantages: Supports arbitrary file position reading.
Disadvantages: Slower than other methods for linear reads.
Using Java NIO Path and BufferedReader for Flexible File Reading
Code Example:
Path path = Paths.get("file.txt");
try (BufferedReader br = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: This method uses Java NIO's Path to locate the file, combined with BufferedReader for efficient line-by-line reading. Files.newBufferedReader supports specifying a character encoding like UTF-8.
Advantages: Simplifies file path handling; flexible for encoding.
Disadvantages: Slightly more complex setup than BufferedReader with FileReader.
Efficient Java File Reading with MappedByteBuffer for Large Files
Code Example:
try (FileChannel channel = FileChannel.open(Paths.get("file.txt"))) {
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
for (int i = 0; i < buffer.limit(); i++) {
System.out.print((char) buffer.get(i));
}
} catch (IOException e) {
e.printStackTrace();
}
Explanation: MappedByteBuffer maps a file to memory, allowing direct access and efficient large file processing.
Advantages: Efficient for large files; fast memory-mapped reading.
Disadvantages: Complex; only useful for large files.
