For modern file I/O in Java, use NIO.2 (java.nio.file) as it provides a more intuitive, feature-rich, and safer API compared to traditional I/O; 2. Use traditional I/O only for legacy code or simple stream operations, as it is blocking and less scalable; 3. Use NIO with channels and selectors for high-performance, non-blocking network programming; 4. Use NIO.2’s WatchService to monitor directory changes and AsynchronousFileChannel for non-blocking file operations; 5. Prefer Paths.get() and try-with-resources for resource management, and avoid loading large files entirely into memory with readAllLines(). NIO.2 is the recommended standard for file handling in Java 7 and later due to its superior design, expressiveness, and performance capabilities.

Java’s I/O (Input/Output) system has evolved significantly over the years, especially with the introduction of NIO (New I/O) in Java 1.4 and the major overhaul in NIO.2 with Java 7. Understanding both traditional I/O and NIO.2 is essential for building efficient, scalable, and maintainable applications that handle file operations, network communication, and data streaming effectively.

Let’s break down the key aspects of Java I/O and NIO.2, compare their strengths, and see how they fit into modern Java development.

1. Traditional Java I/O: The Stream-Based Model

Java’s original I/O system, introduced in early versions of Java, is based on streams — abstract representations of data flow. It’s found in the java.io package and revolves around byte and character streams.

Key Components:

• InputStream / OutputStream: For handling raw bytes (e.g., files, network sockets).
• Reader / Writer: For character-based I/O, supporting encoding/decoding (e.g., FileReader, BufferedReader).
• Decorators: Streams can be wrapped (e.g., BufferedInputStream, DataInputStream) to add functionality.

Example: Reading a File

try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

Characteristics:

• Synchronous and blocking: Each I/O operation blocks the thread until completion.
• Stream-oriented: Data is processed sequentially; no random access.
• Simple for basic tasks: Great for small files or straightforward use cases.

However, traditional I/O struggles with scalability in high-concurrency environments (e.g., servers handling thousands of connections), where blocking I/O leads to thread exhaustion.

2. Java NIO: The Buffer and Channel Model (Java 1.4)

NIO (java.nio) introduced a non-blocking, buffer-centric approach to I/O, designed for high-performance and scalable applications.

Core Concepts:

• Channels: Bidirectional conduits for data (unlike unidirectional streams). Examples: FileChannel, SocketChannel.
• Buffers: Fixed-size data containers (e.g., ByteBuffer, CharBuffer) that hold data being read/written.
• Selectors: Enable multiplexing — a single thread can monitor multiple channels for events (e.g., ready to read/write), crucial for non-blocking network I/O.

Example: Reading a File with NIO

try (FileChannel channel = FileChannel.open(Paths.get("data.txt"), StandardOpenOption.READ)) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (channel.read(buffer) > 0) {
        buffer.flip();
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        buffer.clear();
    }
}

Advantages:

• Non-blocking I/O: Especially useful in network programming (e.g., servers using Selector).
• Memory-mapped files: FileChannel.map() allows mapping a file directly into memory for fast access.
• Better performance for large data transfers.

But NIO’s API is more complex and less intuitive than traditional I/O, and file handling (especially paths and metadata) was still clunky.

3. NIO.2: Modern File I/O (Java 7)

NIO.2, introduced in Java 7 via java.nio.file, overhauled the file system interaction model. It lives in java.nio.file, java.nio.file.attribute, and java.nio.file.spi packages.

Key Features:

• Path Interface: A modern replacement for java.io.File, representing a file system path.
• Files Class: Rich utility methods for common operations (copy, move, delete, read, write).
• FileSystem API: Supports multiple file systems (e.g., ZIP files via FileSystemProvider).
• WatchService: Monitor directories for file changes (create, modify, delete).
• Asynchronous I/O: AsynchronousFileChannel enables truly non-blocking file operations.

Example: Reading a File with NIO.2

Path path = Paths.get("data.txt");
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);

Or even simpler:

String content = Files.readString(path);

Example: Watching a Directory

WatchService watcher = FileSystems.getDefault().newWatchService();
Path dir = Paths.get("watched-folder");
dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE);

// In a loop
WatchKey key = watcher.take();
for (WatchEvent<?> event : key.pollEvents()) {
    System.out.println("File created: "   event.context());
}

Advantages Over Legacy I/O:

• More intuitive and expressive API.
• Better exception handling (specific exceptions like NoSuchFileException).
• Support for symbolic links, file attributes, and permissions.
• Pluggable file system providers (e.g., working with ZIP archives as file systems).

4. When to Use What?

Rule of thumb: For file I/O in modern Java (8 ), prefer NIO.2. It’s safer, more concise, and feature-rich.

5. Practical Tips and Gotchas

• Always use try-with-resources: Both streams and channels are AutoCloseable.
• Prefer Paths.get() over new File(): It returns a Path, the foundation of NIO.2.
• WatchService requires event consumption: Always call pollEvents() and reset() on the key.
• Avoid readAllLines() for large files: It loads everything into memory. Use Files.lines() for streaming:

  try (Stream<String> lines = Files.lines(path)) {
      lines.forEach(System.out::println);
  }

• Use StandardOpenOption for fine-grained control (e.g., CREATE, APPEND).

---

Final Thoughts

While traditional Java I/O is still functional and widely seen in legacy code, NIO.2 is the present and future of file handling in Java. It combines the performance benefits of NIO with a clean, high-level API. For new projects, default to NIO.2 unless you have a specific reason to use lower-level constructs.

Understanding the evolution from java.io → NIO → NIO.2 helps you make informed choices about performance, scalability, and code clarity.

Basically, if you're doing file I/O in Java today, you should be using java.nio.file. The old ways aren’t wrong — they’re just outdated.

The above is the detailed content of A Comprehensive Look at Java I/O and NIO.2. For more information, please follow other related articles on the PHP Chinese website!