How does java.nio's Channel and Buffer abstraction differ fundamentally from the classic java.io Stream model, and what specific capability does this enable for non-blocking I/O?

The classic java.io model is stream-oriented and blocking (a read() call blocks the calling thread until data is available or the stream ends, processing data sequentially byte-by-byte or line-by-line); java.nio introduces a Channel (representing an open connection to an I/O source, like a file or socket) combined with a Buffer (a fixed-capacity container you read data into or write data from, with explicit position/limit/capacity state you manage), and critically, channels can operate in non-blocking mode (a read() call returns immediately, even if no data is currently available, letting a single thread manage many channels simultaneously via a Selector rather than needing one dedicated thread per connection) -- this fundamentally different model is what enables high-concurrency network servers to handle thousands of simultaneous connections without needing a proportional number of OS threads.

// Non-blocking channel-based I/O with a Selector managing multiple connections on ONE thread
Selector selector = Selector.open();
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);

while (true) {
    selector.select();  // blocks only until AT LEAST ONE registered channel is ready
    for (SelectionKey key : selector.selectedKeys()) {
        if (key.isReadable()) { /* handle the ready channel without blocking */ }
    }
}