21.1. Java I/O (java.io Package)

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 operates on the concept of streams. There are two main types of streams: byte streams and character streams. Byte streams are used when dealing with raw binary data, such as image or audio files, and are represented by classes that extend InputStream and OutputStream interfaces. On the other hand, character streams are specifically designed for handling textual data, and they utilize Reader and Writer classes. This separation helps in efficiently processing data according to its type.

Think of byte streams like a plumber dealing with raw water, where every drop of water is important. In contrast, character streams are like an editor working with a piece of text, where the formatting and readability of the words matter greatly. Each type of stream focuses on processing its 'liquid' in an optimal way.

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-independent way

In Java, several classes are specifically designed for byte-level operations. For example, FileInputStream allows you to read raw bytes from a file, while FileOutputStream lets you write bytes to a file. Buffered streams, like BufferedInputStream and BufferedOutputStream, improve efficiency by using an internal buffer, minimizing the number of direct read and write operations. DataInputStream and DataOutputStream are specialized for reading and writing Java primitive data types without being tied to the underlying machine architecture, ensuring compatibility.

Consider FileInputStream like a water pipe that delivers raw water directly when you turn on the tap. BufferedInputStream, however, is like a large water tank that stores water temporarily, allowing you to use it more efficiently without having to handle each individual drop directly. DataInputStream simplifies reading grains of sand, ensuring you only pick them up without worrying about their origin.

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 stream classes in Java facilitate the reading and writing of character data. For instance, FileReader and FileWriter are the simplest forms of character streams, allowing you to read from and write to text files. BufferedReader and BufferedWriter enhance performance by buffering characters to reduce the number of I/O operations. PrintWriter makes it easier to generate formatted output, similar to System.out, by allowing easy formatting of strings for display or file writing.

Think of FileReader as an author reading a manuscript, where each letter matters. Buffering, represented by BufferedReader, is like a proofreader who reads ahead and catches multiple errors at once, ensuring smooth flow and efficiency. PrintWriter is akin to a typesetter who takes the author's notes and lays them out beautifully, ensuring they are ready for publication.

The java.io.File class represents a file or directory path in an abstract manner. File file = new File("example.txt"); if (file.exists()) { System.out.println("File exists at: " + file.getAbsolutePath()); }

The java.io.File class is essential for file manipulation in Java. It abstracts the representation of directories and files, allowing programmers to perform various file operations without needing direct access to the filesystem. For instance, the code creates a new File object with a specified path and checks if the file exists. If it does, it prints the file's absolute path, demonstrating how the class can be utilized to interact with the file system.

Imagine the File class as a property manager who knows about all the properties available. When you ask, 'Does this property exist?' the manager can efficiently check and give you the details, just like the File object checks for an existing file or directory.

Serialization allows saving the state of an object. ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.ser")); out.writeObject(someObject); out.close();

Serialization is the process of converting an object's state into a byte stream, allowing it to be easily saved to a file or transmitted over a network. The ObjectOutputStream class handles the serialization process. In the example, an ObjectOutputStream is created to write the state of 'someObject' to a file named 'data.ser'. This allows the object to be reconstructed later from the serialized data, making it a crucial aspect of data persistence in Java.

Consider serialization like taking a snapshot of a moment in time. Just as a photograph freezes a scene for future viewing, serialization captures the current state of an object, allowing it to be 'revived' exactly as it was when saved.

--