11.1 Classic Java I/O Streams and Readers/Writers

Classic Java I/O: Streams, Readers, Writers, and Buffered I/O

Input/Output (I/O) in Java provides the fundamental architecture for reading from and writing to external data sources, including physical disk files, network sockets, in-memory buffers, and system consoles. The original java.io package organizes all data movement around sequential streams.

For the Oracle Certified Professional: Java SE 21 Developer (1Z0-830) exam, developers must master the separation between 8-bit byte streams and 16-bit character streams, the Decorator design pattern used in stream chaining, modern transfer methods such as transferTo(), character encoding standards under JEP 400, stream mark/reset capabilities, and interactive terminal handling using java.io.Console.

1. The Classic I/O Architecture: Byte vs. Character Streams

The java.io package cleanly bifurcates all stream operations based on data granularity:

1. Byte Streams (InputStream and OutputStream): Transfer raw binary data as 8-bit bytes (values ranging from 0 to 255, or signed -128 to 127). Byte streams are used for binary payloads, images, audio, compiled .class files, compressed ZIP archives, and serialized objects.
2. Character Streams (Reader and Writer): Transfer 16-bit Unicode characters (char). Character streams automatically handle character encoding and decoding, translating raw byte sequences to and from human-readable characters according to a specified Charset.

Node Streams vs. Processing (Wrapper) Streams

Java Classic I/O heavily relies on the Decorator Design Pattern. Stream classes are divided into two operational categories:

• Node Streams (Low-Level Streams): Connect directly to a physical data source or destination (such as a disk file, memory array, or network socket). Examples include FileInputStream, FileOutputStream, FileReader, FileWriter, ByteArrayInputStream, ByteArrayOutputStream, CharArrayReader, and CharArrayWriter.
• Processing Streams (High-Level / Wrapper Streams): Wrap around an existing stream to add functionality such as buffering, primitive data parsing, character encoding translation, or object serialization. Examples include BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, DataInputStream, DataOutputStream, and ObjectInputStream.

// Chaining a low-level file node stream with a character bridge and a buffering decorator:
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(
            new FileInputStream("application.log"), 
            StandardCharsets.UTF_8))) {
    
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println("Log entry: " + line);
    }
}

[!IMPORTANT] Closing Chained Streams: When wrapper streams are chained together in a Decorator pipeline, invoking close() on the outermost wrapper stream automatically flushes and closes all underlying wrapped streams. You do not need to call close() on each individual inner stream. When using try-with-resources, declare only the outermost wrapper or declare each in order.

2. Byte Streams: InputStream and OutputStream

InputStream and OutputStream are the abstract roots of the byte stream hierarchy.

Reading Bytes from an InputStream

The fundamental read() methods in InputStream return an int rather than a byte:

• public abstract int read() throws IOException: Reads the next single byte of data. Returns an int in the range 0 to 255. If the end of the stream (EOF) is reached, it returns -1.
• public int read(byte[] b) throws IOException: Reads up to b.length bytes into the specified byte array. Returns the actual count of bytes read as an int, or -1 if EOF is reached before reading any bytes.
• public int read(byte[] b, int off, int len) throws IOException: Reads up to len bytes into array b starting at index offset off. Returns the number of bytes read, or -1 if EOF is reached.

try (InputStream in = new FileInputStream("source.bin")) {
    int byteRead;
    // Sentinel loop pattern: read() returns -1 at end-of-stream
    while ((byteRead = in.read()) != -1) {
        byte b = (byte) byteRead; // Cast int [0..255] back to signed byte
        // Process individual byte...
    }
}

Why read() Returns int Instead of byte

In Java, the primitive byte type is signed, with a numerical range of -128 to +127. A byte value of 0xFF represents -1 in two's complement arithmetic. If read() returned a byte, the valid data byte 0xFF (-1) would be completely indistinguishable from the end-of-stream sentinel signal (-1). Returning an int allows valid byte values to be represented as positive unsigned integers from 0 to 255, while reserving the integer -1 exclusively for EOF.

Modern Java Byte Stream Methods (Java 9 to Java 21)

Modern Java releases introduced high-performance methods directly onto InputStream and OutputStream:

// 1. in.transferTo(OutputStream out) - Java 9+
// Reads all remaining bytes from this input stream and writes them directly to the target output stream.
// Returns the total number of bytes transferred as a 64-bit long. Does not close either stream.
try (InputStream in = new FileInputStream("source.bin");
     OutputStream out = new FileOutputStream("backup.bin")) {
    long bytesTransferred = in.transferTo(out);
    System.out.println("Transferred: " + bytesTransferred + " bytes");
}

// 2. in.readAllBytes() - Java 9+
// Reads all remaining bytes into a newly allocated byte array on the heap.
try (InputStream in = new FileInputStream("payload.dat")) {
    byte[] allData = in.readAllBytes();
}

// 3. in.readNBytes(int len) - Java 11+
// Reads up to len bytes into a newly allocated byte array.
try (InputStream in = new FileInputStream("header.dat")) {
    byte[] header = in.readNBytes(128); // Returns array of length <= 128
}

// 4. in.readNBytes(byte[] b, int off, int len) - Java 9+
// Reads exactly len bytes into array b starting at offset off, blocking until len bytes are read or EOF is reached.
// Returns the actual count of bytes read into the buffer.

Writing Bytes to an OutputStream

• public abstract void write(int b) throws IOException: Writes the specified byte (the 8 low-order bits of the int argument; the 24 high-order bits are discarded).
• public void write(byte[] b) throws IOException: Writes all b.length bytes from the byte array.
• public void write(byte[] b, int off, int len) throws IOException: Writes len bytes from array b starting at offset off.
• public void flush() throws IOException: Flushes this output stream and forces any buffered output bytes to be written out to the underlying operating system device or socket buffer.

Buffered Byte Streams: BufferedInputStream and BufferedOutputStream

Direct file operations through FileInputStream or FileOutputStream invoke an underlying operating system system call for every byte read or written, creating substantial kernel transition overhead. Wrapping node streams with BufferedInputStream and BufferedOutputStream maintains an internal memory buffer (default size: 8192 bytes / 8 KB):

try (InputStream in = new BufferedInputStream(new FileInputStream("large.iso"));
     OutputStream out = new BufferedOutputStream(new FileOutputStream("copy.iso"))) {
    in.transferTo(out);
    out.flush(); // Flushes remaining buffered bytes to disk
}

Specialized Byte Streams: DataInputStream and DataOutputStream

DataInputStream and DataOutputStream implement DataInput and DataOutput to read and write Java primitive data types and portable strings in machine-independent binary format:

try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("records.dat"))) {
    dos.writeInt(101);
    dos.writeDouble(99.95);
    dos.writeBoolean(true);
    dos.writeUTF("Alice Smith"); // Modified UTF-8 format
}

try (DataInputStream dis = new DataInputStream(new FileInputStream("records.dat"))) {
    int id = dis.readInt();
    double price = dis.readDouble();
    boolean active = dis.readBoolean();
    String name = dis.readUTF();
    // Fields must be read in the exact order and types they were written!
}

3. Character Streams: Reader, Writer, and Charset Standards

Character streams process sequences of 16-bit Unicode characters.

Standard Charset and JEP 400

Prior to Java 18, the default character encoding depended on the host operating system, regional locale, and user configuration (e.g., Windows-1252 on Windows, UTF-8 on Linux and macOS). This led to severe data corruption bugs when text files generated on one operating system were read on another.

Starting with Java 18 (JEP 400), the standard default charset for all standard Java APIs is unconditionally UTF-8 across all operating systems and runtimes.

// In Java 21, FileReader and FileWriter use StandardCharsets.UTF_8 by default
try (FileWriter writer = new FileWriter("notes.txt", StandardCharsets.UTF_8, true)) {
    // The boolean parameter 'true' enables append mode (writing to end of file)
    writer.write("Appending entry to journal.
");
}

BufferedReader and BufferedWriter

BufferedReader and BufferedWriter are essential for efficient character stream processing:

• BufferedReader.readLine(): Reads a line of text. A line is considered terminated by line feed ( ), carriage return ( ), or carriage return followed immediately by line feed ( ). Returns the String content without any terminating characters, or null when the end of the stream is reached.
• BufferedReader.lines(): Returns a lazy Stream<String> containing the lines read from this BufferedReader.
• BufferedWriter.newLine(): Writes a platform-specific line separator string (e.g., on Windows, on Unix) to the stream.

try (BufferedReader br = new BufferedReader(new FileReader("data.csv", StandardCharsets.UTF_8))) {
    // Functional line processing via Stream API
    br.lines()
      .filter(line -> !line.startsWith("#")) // Skip comment lines
      .map(String::trim)
      .forEach(System.out::println);
}

PrintWriter and PrintStream

PrintStream (byte stream wrapper, used by System.out and System.err) and PrintWriter (character stream wrapper) provide high-level formatted output methods (print, println, printf, format).

Key characteristics tested on the 1Z0-830 exam:

• No Checked Exceptions: Methods in PrintWriter and PrintStream never throw checked IOException. Instead, any internal I/O errors set an internal boolean error flag that can be checked programmatically using the checkError() method.
• Auto-Flush Configuration: Both classes feature constructor overloads with an autoFlush boolean parameter (e.g., new PrintWriter(writer, true)). When autoFlush is true, invoking println(), printf(), or format() automatically flushes the buffer.

try (PrintWriter pw = new PrintWriter(new FileWriter("report.txt"), true)) {
    pw.printf("Student: %s | Score: %.2f%n", "Eleanor", 94.5);
    if (pw.checkError()) {
        System.err.println("An I/O error occurred during writing!");
    }
}

4. Stream Navigation: mark(), reset(), and skip()

The InputStream and Reader classes provide navigation primitives to skip forward or backtrack:

• boolean markSupported(): Returns true if this stream instance supports the mark() and reset() methods.
• void mark(int readAheadLimit): Marks the current position in this input stream. The readAheadLimit argument specifies the maximum number of bytes/chars that can be read before the marked position becomes invalid.
• void reset() throws IOException: Repositions this stream to the position at the time the mark() method was last called. If markSupported() returns false or the mark has been invalidated by reading beyond readAheadLimit, reset() throws an IOException.
• long skip(long n) throws IOException: Skips over and discards up to n bytes or characters from the stream, returning the actual number of bytes/characters skipped.

InputStream is = new BufferedInputStream(new FileInputStream("data.bin"));
if (is.markSupported()) { // BufferedInputStream supports mark/reset (FileInputStream does NOT!)
    is.mark(100); // Read up to 100 bytes ahead while retaining mark
    int b1 = is.read();
    int b2 = is.read();
    is.reset(); // Returns stream read position back to the mark!
    int b1Again = is.read(); // Reads b1 again
}

[!WARNING] Direct node streams like FileInputStream and FileReader do NOT support mark() and reset() (markSupported() returns false). Invoking reset() on them immediately throws IOException. You must wrap them in a BufferedInputStream or BufferedReader to enable mark/reset capabilities.

5. Interactive Terminal Operations with java.io.Console

Java provides java.io.Console as a singleton interface to interact with the physical operating system terminal attached to the current JVM process.

Console console = System.console();
if (console == null) {
    System.out.println("No interactive console attached (running inside IDE, background daemon, or redirected I/O).");
    return;
}

String username = console.readLine("Enter username: ");
char[] password = console.readPassword("Enter password for %s: ", username);
try {
    // Process login credentials...
    System.out.println("Authenticating user: " + username);
} finally {
    // Security Best Practice: Zero out password memory immediately!
    java.util.Arrays.fill(password, ' ');
}

Critical Exam Rules for java.io.Console

1. System.console() Null Check:
   • If the application is executed inside an IDE (IntelliJ IDEA, Eclipse, VS Code), run as a background service/daemon, or if standard I/O is redirected via shell pipes (java App < input.txt > output.txt), System.console() returns null.
   • Invoking methods on console without performing a null check will throw NullPointerException.
2. readPassword() Security Guarantee:
   • console.readPassword() disables terminal character echoing and returns a char[] (character array), not a java.lang.String.
   • In Java, String objects are immutable and interned or retained in the JVM heap until garbage collected and memory overwritten. A char[] is mutable and can be immediately scrubbed (e.g., Arrays.fill(password, ' ')) as soon as authentication finishes, preventing sensitive credentials from leaking in heap memory dumps.
3. Format String Support:
   • Both readLine(String fmt, Object... args) and readPassword(String fmt, Object... args) accept optional printf-style format strings to prompt the user.
4. Accessing Underlying Reader and Writer:
   • console.reader() returns a Reader.
   • console.writer() returns a PrintWriter.

6. Summary Comparison Table