Java NIO Basics: Channels and Buffers

Classic java.io (the "old I/O" package built around Streams like FileInputStream and FileOutputStream) reads and writes data one byte or char at a time, in a blocking, sequential fashion. Java NIO ("New I/O", introduced in Java 1.4 and significantly expanded since) offers an alternative model built around Buffers and Channels that supports block-based transfer, direct memory access, and non-blocking I/O — capabilities the original streams-based API was never designed for.

NIO is not a strict replacement for java.io — both are still widely used, and for many simple file-reading tasks, java.io (or the higher-level java.nio.file.Files utility methods) remains simpler to write. But understanding NIO's Buffer/Channel model is essential for anything involving high-throughput I/O, non-blocking network servers, or memory-mapped file access.

Why it matters

High-performance servers, including the ones underneath Netty, Tomcat's NIO connector and Kafka, read and write through channels and buffers. The buffer's position and limit, and the flip() call that switches it from writing to reading, are the part everyone gets wrong at first; a forgotten flip reads nothing at all.

Buffer: A Fixed-Size Container With Position and Limit

A Buffer (e.g. ByteBuffer, CharBuffer) is a fixed-capacity container for a primitive data type that data is read into or written out of in bulk. Unlike a Stream, which just pushes bytes through one at a time, a Buffer is a block of memory you actively manage using three key properties:

• capacity — the fixed, unchanging total size of the buffer, set when it is created.
• position — the index of the next element to be read or written; it advances as you get/put data.
• limit — the index of the first element that should not be read or written; it marks the boundary of valid data currently in the buffer.

The flip() and clear() Idiom

A very common NIO pattern is writing data into a buffer (e.g., reading from a channel into it), then calling buffer.flip() before reading that data back out. flip() sets limit to the current position (marking exactly how much data is valid) and resets position to 0, effectively switching the buffer from "fill mode" to "drain mode." After consuming the data, buffer.clear() resets position to 0 and limit to capacity, preparing the buffer to be filled again. Forgetting to call flip() before reading is one of the most common NIO bugs, since without it, you'd try to read starting from wherever the write left off, getting no data or garbage.

Channel: The Conduit Between Buffers and I/O Sources

A Channel represents an open connection to an I/O source or destination — a file (FileChannel), a network socket (SocketChannel), or other resources. Unlike a Stream, a Channel is bidirectional-capable in principle (a FileChannel opened appropriately can both read and write) and always transfers data into or out of Buffers, never as loose individual bytes. This block-oriented design, combined with the JVM's ability to allocate "direct" buffers backed by native memory outside the regular garbage-collected heap, allows the OS to move data more efficiently — sometimes bypassing an extra copy step that classic streams require, and enabling non-blocking mode for network channels so a single thread can manage many connections instead of blocking one thread per connection.

Reading a File with FileChannel

A typical FileChannel read loop allocates a ByteBuffer, repeatedly calls channel.read(buffer) to fill it, flips the buffer to switch to reading mode, processes or extracts the data, then clears the buffer before the next read. The channel's read() method returns the number of bytes read, or -1 when the end of the file/stream has been reached, which is the loop's termination condition — directly analogous to how InputStream.read() signals end-of-stream, but operating on whole blocks of bytes at once via the buffer instead of one byte/char at a time.

Examples

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileChannelDemo {
    public static void main(String[] args) throws IOException {
        String path = "nio-demo.txt";

        // Write some sample content first so the read has something to find.
        try (FileOutputStream fos = new FileOutputStream(path)) {
            fos.write("Hello from Java NIO!".getBytes(StandardCharsets.UTF_8));
        }

        // Read the file back using a FileChannel and a ByteBuffer.
        try (FileChannel channel = FileChannel.open(Paths.get(path), StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(64);
            StringBuilder content = new StringBuilder();

            int bytesRead = channel.read(buffer);
            while (bytesRead != -1) {
                buffer.flip(); // switch from "fill" mode to "drain" mode
                while (buffer.hasRemaining()) {
                    content.append((char) buffer.get());
                }
                buffer.clear(); // reset for the next read
                bytesRead = channel.read(buffer);
            }

            System.out.println("File contents: " + content);
        }
    }
}

File contents: Hello from Java NIO!

import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

public class BufferLifecycleDemo {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(20);
        System.out.println("After allocate -> capacity=" + buffer.capacity()
                + " position=" + buffer.position() + " limit=" + buffer.limit());

        buffer.put("Hi NIO".getBytes(StandardCharsets.UTF_8));
        System.out.println("After put -> position=" + buffer.position() + " limit=" + buffer.limit());

        buffer.flip();
        System.out.println("After flip -> position=" + buffer.position() + " limit=" + buffer.limit());

        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        System.out.println("Read back: " + new String(data, StandardCharsets.UTF_8));

        buffer.clear();
        System.out.println("After clear -> position=" + buffer.position() + " limit=" + buffer.limit());
    }
}

After allocate -> capacity=20 position=0 limit=20
After put -> position=6 limit=20
After flip -> position=0 limit=6
Read back: Hi NIO
After clear -> position=0 limit=20

Exercise

Put the bytes for h and i into an 8-byte buffer and print its position and limit. Flip the buffer and print the position and limit again. Then read the remaining bytes and print them as text.

Expected output: 2 8, 0 2, hi (one per line)

import java.nio.ByteBuffer;

public class BufferStates {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(8);

        // TODO: put the bytes 'h' and 'i', then print position and limit
        // TODO: flip, then print position and limit
        // TODO: read the remaining bytes into a StringBuilder and print it
    }
}

import java.nio.ByteBuffer;

public class BufferStates {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(8);

        buffer.put((byte) 'h');
        buffer.put((byte) 'i');
        System.out.println(buffer.position() + " " + buffer.limit()); // 2 8

        buffer.flip();
        System.out.println(buffer.position() + " " + buffer.limit()); // 0 2

        StringBuilder text = new StringBuilder();
        while (buffer.hasRemaining()) {
            text.append((char) buffer.get());
        }
        System.out.println(text); // hi
    }
}

Quick quiz

Interview questions