Java I/O Streams Fundamentals

Java's I/O (input/output) system is built around the idea of a "stream" — a sequential flow of data moving from a source (a file, the network, memory, the keyboard) to a destination, one piece at a time. The java.io package organizes these streams into two parallel class hierarchies: one for raw bytes and one for characters, and understanding why both exist — and when to use each — is fundamental to reading and writing data correctly in Java.

Why it matters

Reading files, handling uploads, calling other services and writing logs all go through streams. The whole of java.io follows from two ideas covered here: bytes versus characters, and wrapping one stream in another to add a feature such as buffering. Closing streams correctly is also what prevents resource leaks in long-running programs.

Byte Streams: InputStream and OutputStream

InputStream and OutputStream are the abstract root classes for reading and writing raw 8-bit bytes. They are used for any data that isn't inherently text: images, audio, compiled class files, serialized objects, or network protocols. Common concrete subclasses include FileInputStream/FileOutputStream (files), ByteArrayInputStream/ByteArrayOutputStream (in-memory byte arrays), and BufferedInputStream/BufferedOutputStream, which wrap another stream to reduce the number of expensive underlying I/O calls by reading and writing in larger chunks.

Character Streams: Reader and Writer

Reader and Writer are the abstract root classes for reading and writing 16-bit Unicode characters rather than raw bytes. Character streams exist because text is not just bytes — it is bytes interpreted according to a specific character encoding (UTF-8, UTF-16, ISO-8859-1, and so on), and if you read text data through a raw byte stream without applying the correct encoding, multi-byte characters (accented letters, non-Latin scripts, emoji) can be corrupted. Reader/Writer subclasses such as FileReader/FileWriter and InputStreamReader/OutputStreamWriter handle that byte-to-character (and character-to-byte) conversion internally, using either a specified charset or the platform default. BufferedReader/BufferedWriter add buffering on top, and BufferedReader additionally provides the convenient readLine() method.

Try-With-Resources for Automatic Closing

Every stream, reader, and writer implements Closeable, and holds onto an underlying operating system resource (a file handle, a socket) that must be released when you are done, or it will leak. Prior to Java 7, this required a verbose try/finally block to guarantee closing even if an exception occurred mid-operation. The try-with-resources statement, try (Resource r = ...) { ... }, automatically calls close() on every resource declared in its parentheses when the block exits — whether normally or via an exception — making resource leaks far less likely and the code noticeably shorter.

Examples

import java.io.*;

public class ByteStreamDemo {
    public static void main(String[] args) throws IOException {
        try (OutputStream out = new FileOutputStream("data.bin")) {
            out.write("Hello".getBytes());
        }

        try (InputStream in = new FileInputStream("data.bin")) {
            byte[] buffer = new byte[5];
            int bytesRead = in.read(buffer);
            System.out.println("Bytes read: " + bytesRead);
            System.out.println("Content: " + new String(buffer, 0, bytesRead));
        }
    }
}

Bytes read: 5
Content: Hello

import java.io.*;

public class CharacterStreamDemo {
    public static void main(String[] args) throws IOException {
        try (Writer writer = new FileWriter("notes.txt")) {
            writer.write("Character streams handle text encoding correctly.");
        }

        try (BufferedReader reader = new BufferedReader(new FileReader("notes.txt"))) {
            String line = reader.readLine();
            System.out.println(line);
        }
    }
}

Character streams handle text encoding correctly.

Exercise

Copy every byte from the input stream to the output stream using a small buffer, then print the copied text. Both streams are in memory, so no file is needed. Use try-with-resources.

Expected output: hello streams

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

public class CopyBytes {
    public static void main(String[] args) throws IOException {
        byte[] source = "hello streams".getBytes(StandardCharsets.UTF_8);
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        try (InputStream in = new ByteArrayInputStream(source)) {
            byte[] buffer = new byte[4];
            // TODO: read into the buffer until read() returns -1,
            //       writing only the bytes that were actually read
        }

        System.out.println(new String(out.toByteArray(), StandardCharsets.UTF_8));
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

public class CopyBytes {
    public static void main(String[] args) throws IOException {
        byte[] source = "hello streams".getBytes(StandardCharsets.UTF_8);
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        try (InputStream in = new ByteArrayInputStream(source)) {
            byte[] buffer = new byte[4];
            int count;
            while ((count = in.read(buffer)) != -1) {
                out.write(buffer, 0, count); // only the bytes just read
            }
        }

        System.out.println(new String(out.toByteArray(), StandardCharsets.UTF_8)); // hello streams
    }
}

Quick quiz

Interview questions