21.1.1. Streams in Java

Java I/O uses streams to read and write data:

In Java, streams provide a way to handle input and output of data. Streams can be broadly categorized into two types: byte streams and character streams. They serve the purpose of reading data from sources (like files) or writing data to destinations (like files or consoles).

You can think of streams like a water pipe – the data flows through it just as water flows through a pipe. Depending on the type of data (water or air), you might choose a different type of pipe (stream).

• Byte Streams – For handling raw binary data (classes under InputStream and OutputStream).

Byte streams operate at the byte level and are used for binary data, which means they can handle all kinds of data including images, audio, and other file formats. The primary classes that deal with byte streams in Java are InputStream for reading data and OutputStream for writing data.

Imagine a music file that needs to be played on your computer. The byte stream is like the audio wires connecting your speaker to your device, transferring the raw sound data directly, without any 'formatting' or 'interpretation' for human language.

• Character Streams – For handling textual data (classes under Reader and Writer).

Character streams work with characters instead of bytes, which is useful for text data. They enable reading and writing text while handling different character encodings. The relevant classes for this category are Reader for reading text data and Writer for writing text.

Think about reading a book. The character stream helps you read the text directly in your language without needing to translate or convert it – just like how you read the words aloud without changing them into sounds.

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

Java provides several classes for byte streams, each with specific purposes:

• FileInputStream: Reads raw bytes from a file.
• FileOutputStream: Writes raw bytes to a file.
• BufferedInputStream and BufferedOutputStream: Enhance performance by buffering data, reducing the number of I/O operations.
• DataInputStream and DataOutputStream: Handle reading and writing Java's primitive data types in a consistent way across different platforms.

Consider the FileOutputStream like a grocery bag where you put items directly (raw bytes). If you use BufferedOutputStream, it's like having a larger cart that allows you to carry more at once, making it quicker to unload at the cash register.

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

Similar to byte streams, there are classes designed for character data:

• FileReader and FileWriter: Used for reading and writing characters to files, respectively.
• BufferedReader and BufferedWriter: Provide buffering for character data to improve efficiency.
• PrintWriter: Allows formatted output, making it easier to write text with formatting features like line breaks and formatted strings.

Using PrintWriter is like writing a letter with a fancy pen that can do more than just basic lines and letters; it helps you format your message exactly how you want it, making it presentable.

--