21. Java I/O and NIO

Efficient data input and output operations are crucial in any programming language, and Java provides a robust set of APIs to handle them. Java I/O (Input/Output) and NIO (New Input/Output) are the two primary frameworks used to perform file, stream, and buffer operations. This chapter dives deep into both classic Java I/O and the newer, more performant Java NIO package introduced in JDK 1.4, which offers advanced features such as non-blocking I/O, memory-mapped files, channels, and selectors.

This introduction emphasizes the importance of data input and output in programming. Java's two main frameworks for handling I/O are Java I/O and Java NIO. Java I/O is the classic method for input and output operations, while Java NIO, introduced in JDK 1.4, is more advanced and offers improved performance with non-blocking capabilities, memory-mapped files, and better concurrency through channels and selectors.

Think of Java I/O like traditional postal services for sending letters (data) where each letter must be delivered one by one (blocking I/O). Java NIO, on the other hand, is like using express courier services where multiple letters can be sent simultaneously without waiting (non-blocking I/O), making it faster and more efficient.

Java I/O uses streams to read and write data: • Byte Streams – For handling raw binary data (classes under InputStream and OutputStream). • Character Streams – For handling textual data (classes under Reader and Writer).

Java I/O utilizes streams, which are sequences of data. There are two primary types of streams: Byte Streams, which deal with raw binary data (like images or files), and Character Streams, which deal specifically with text data (like reading words from a text file). Byte Streams are implemented through classes like InputStream and OutputStream, while Character Streams utilize classes like Reader and Writer.

Imagine Byte Streams as a pipe that carries water (binary data) where anything can flow through regardless of form. Character Streams, however, are more like a specialized tube that only allows air (text data) to pass through, ensuring that only the right kind of data is moved.

Common Byte Stream Classes Class Description FileInputStream Reads raw bytes from a file FileOutputStream Writes raw bytes to a file BufferedInputStream / Wraps streams for efficient buffered I/O BufferedOutputStream DataInputStream / DataOutputStream Reads/writes Java primitives in a machine- dependent way

In Java, there are several key classes for working with byte streams. FileInputStream allows you to read raw bytes from a file, while FileOutputStream enables you to write raw bytes back to a file. BufferedInputStream and BufferedOutputStream offer buffering features to enhance efficiency by reducing the number of read/write operations. DataInputStream and DataOutputStream facilitate reading and writing Java primitive types (like int, float) in a manner that's compatible across different systems.

Using FileInputStream is like using a straw to sip your drink (raw data). BufferedInputStream is similar to using a larger cup that lets you store more drink at once, fulfilling every sip more quickly. DataInputStream can be likened to a translator that converts your drink into flavored sips (handling complex data types) so that anyone can enjoy it, regardless of their taste.

Common Character Stream Classes Class Description FileReader / FileWriter Reads/writes characters from/to a file BufferedReader / BufferedWriter Buffers character streams PrintWriter Conveniently writes formatted text

Character streams in Java make it effective to work with text data. FileReader and FileWriter are used to read from and write to files in character format. BufferedReader and BufferedWriter improve the efficiency of reading and writing by using buffers to store data temporarily. PrintWriter is a convenient class for outputting formatted text, making it easier to write human-readable text onto files.

Imagine FileReader as a person reading a book aloud. BufferedReader is like a friend who whispers suggestions to speed up the reading process when they sense a long segment coming. PrintWriter can be compared to a professional editor who not only reads but also ensures that the written format is polished and looks good for others.

Java NIO offers a more flexible and scalable I/O framework using buffers and channels. • Buffers – Containers for data of a specific primitive type. • Channels – Bi-directional data transfer between buffers and I/O devices. • Selectors – Handle multiple channels using a single thread (non-blocking I/O). • Paths and Files – Introduced in Java 7 (java.nio.file.*) to replace File.

Java NIO introduces significant concepts that enhance I/O operations. Buffers act as temporary storage for data (like a waiting area), Channels are pathways that facilitate data transfer between buffers and I/O devices (like a freeway), and Selectors allow a single thread to manage multiple channels, promoting non-blocking I/O operations. The java.nio.file package introduces a more modern approach to file operations, replacing the older java.io.File.

Buffers can be thought of as parking lots where cars (data) wait before heading out. Channels are the highways connecting these parking lots to different destinations (files or other I/O devices). Selectors are the traffic lights that control the flow of traffic allowing certain lanes to go at once, thus enabling efficient management of multiple streams of traffic instead of being stuck at every light.

--