Java I/O and NIO

This section covers Java's Input/Output (I/O) and New Input/Output (NIO) APIs, highlighting their functionalities and differences.

Java I/O and NIO are essential frameworks for performing data input and output operations in Java. The section explains the classic I/O methods, the more efficient NIO methods including buffers and channels, and the introduction of advanced features like non-blocking I/O, all of which are crucial for developing efficient applications.

Java I/O and NIO

Introduction

Efficient data input and output operations are paramount in programming, and Java's robust APIs are adept at handling them. The classic Java I/O API operates predominantly with streams while the Java NIO introduced in JDK 1.4 adopts a more advanced design that supports non-blocking I/O, buffers, channels, and selectors.

Java I/O

Streams in Java

Java I/O uses two main types of streams to read and write data:

• Byte Streams handle raw binary data via InputStream and OutputStream classes.
• Character Streams manage textual data via Reader and Writer classes.

Common Classes:

• Byte Streams: FileInputStream, FileOutputStream, BufferedInputStream, BufferedOutputStream, DataInputStream, DataOutputStream
• Character Streams: FileReader, FileWriter, BufferedReader, BufferedWriter, PrintWriter

File Class

The java.io.File class represents a directory or file path. Example usage:

File file = new File("example.txt");

It allows operations like checking file existence.

Serialization

Serialization is the process of converting an object's state into a byte stream, enabling storage. Example:

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.ser"));
out.writeObject(someObject);
out.close();

Java NIO

Java NIO is designed for high-performance file and stream handling and introduces new concepts:

• Buffers: Data containers (ByteBuffer, CharBuffer, etc.).
• Channels: Connections for data transfer, like FileChannel and SocketChannel.
• Selectors: Manage non-blocking I/O using a single thread.
• Paths/Files: Improved file handling over java.io.File introduced in Java 7.

Buffer Classes:

Example of using ByteBuffer:

ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put((byte)123);
buffer.flip();
byte b = buffer.get();

Channel Classes:

Channels establish connections to files or sockets. Example of reading a file using FileChannel:

RandomAccessFile file = new RandomAccessFile("data.txt", "r");
FileChannel channel = file.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);

Selectors:

Selectors facilitate monitoring multiple channels for I/O events. A basic selector usage example:

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
    selector.select();
}

Path, Paths, and Files (Java 7+)

Example usage:

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

Comparison: Java I/O vs NIO

• Data Handling: Stream-based vs. Buffer-based
• Blocking Mode: Always blocking in I/O vs. non-blocking in NIO
• Performance: Slower vs. faster for large data I/O
• Thread Usage: One thread per stream vs. one thread for multiple channels.

Advanced NIO: Memory-Mapped Files

Allows mapping files into memory for efficient access. Example:

FileChannel channel = FileChannel.open(path, StandardOpenOption.READ);
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

Java NIO.2 Enhancements (Java 7+)

Improvements include the WatchService API for monitoring file system events and better symbolic link handling. An example:

WatchService watcher = FileSystems.getDefault().newWatchService();

Summary

Understanding Java I/O and NIO is crucial for efficient application development. While classic I/O is straightforward, NIO offers scalability and high performance.