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.