Java NIO (New I/O) in Java

Java NIO (New I/O) is an alternative I/O API introduced in Java 1.4 that provides high-speed, block-oriented I/O capabilities. It's designed to be more efficient than traditional Java I/O for certain use cases.

1. NIO vs Traditional I/O

Key Differences

Traditional I/O	Java NIO
Stream-oriented	Buffer-oriented
Blocking I/O	Non-blocking I/O
Synchronous	Asynchronous
One thread per connection	One thread can handle multiple connections

2. Core Components of NIO

Basic Imports

import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.FileChannel; import java.nio.channels.SocketChannel; import java.nio.channels.ServerSocketChannel; import java.nio.channels.DatagramChannel; import java.nio.file.*; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; import java.io.IOException; import java.util.EnumSet;

3. Buffers

Buffers are the fundamental data structure in NIO used for reading and writing data.

Buffer Types

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

Buffer Properties

Capacity: Maximum number of elements buffer can hold
Position: Current position for reading/writing
Limit: First element that should not be read/written
Mark: Remembered position for reset

Basic Buffer Operations

public class BufferExample { public static void main(String[] args) { // Create a ByteBuffer with capacity of 1024 bytes ByteBuffer buffer = ByteBuffer.allocate(1024); System.out.println("Initial state:"); printBufferInfo(buffer); // Write data to buffer String data = "Hello, NIO!"; buffer.put(data.getBytes()); System.out.println("\nAfter putting data:"); printBufferInfo(buffer); // Flip buffer for reading buffer.flip(); System.out.println("\nAfter flip (ready for reading):"); printBufferInfo(buffer); // Read data from buffer byte[] readData = new byte[buffer.remaining()]; buffer.get(readData); System.out.println("Read data: " + new String(readData)); System.out.println("\nAfter reading:"); printBufferInfo(buffer); // Clear buffer for reuse buffer.clear(); System.out.println("\nAfter clear:"); printBufferInfo(buffer); } private static void printBufferInfo(ByteBuffer buffer) { System.out.println("Position: " + buffer.position()); System.out.println("Limit: " + buffer.limit()); System.out.println("Capacity: " + buffer.capacity()); System.out.println("Remaining: " + buffer.remaining()); } }

Direct vs Non-Direct Buffers

public class DirectBufferExample { public static void main(String[] args) { // Non-direct buffer (allocated in JVM heap) ByteBuffer heapBuffer = ByteBuffer.allocate(1024); System.out.println("Is direct: " + heapBuffer.isDirect()); // Direct buffer (allocated in OS memory) ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); System.out.println("Is direct: " + directBuffer.isDirect()); // Direct buffers are faster for I/O operations but // more expensive to allocate and deallocate } }

Buffer View Operations

public class BufferViews { public static void main(String[] args) { ByteBuffer byteBuffer = ByteBuffer.allocate(1024); // Write some data for (int i = 0; i < 10; i++) { byteBuffer.put((byte) i); } byteBuffer.flip(); // Create read-only view ByteBuffer readOnlyBuffer = byteBuffer.asReadOnlyBuffer(); System.out.println("Read-only: " + readOnlyBuffer.isReadOnly()); // Create duplicate ByteBuffer duplicateBuffer = byteBuffer.duplicate(); // Create slice (shares portion of original buffer) byteBuffer.position(2); byteBuffer.limit(6); ByteBuffer sliceBuffer = byteBuffer.slice(); System.out.println("Original capacity: " + byteBuffer.capacity()); System.out.println("Slice capacity: " + sliceBuffer.capacity()); } }

4. Channels

Channels represent connections to entities capable of performing I/O operations.

FileChannel Examples

Reading from a File

public class FileChannelReadExample { public static void main(String[] args) { Path path = Paths.get("test.txt"); try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) { ByteBuffer buffer = ByteBuffer.allocate(1024); while (channel.read(buffer) > 0) { buffer.flip(); // Prepare buffer for reading // Process data while (buffer.hasRemaining()) { System.out.print((char) buffer.get()); } buffer.clear(); // Prepare buffer for next read } } catch (IOException e) { e.printStackTrace(); } } }

Writing to a File

public class FileChannelWriteExample { public static void main(String[] args) { Path path = Paths.get("output.txt"); String data = "Hello, Java NIO!\nThis is a test file."; try (FileChannel channel = FileChannel.open( path, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) { ByteBuffer buffer = ByteBuffer.wrap(data.getBytes()); channel.write(buffer); System.out.println("Data written successfully"); } catch (IOException e) { e.printStackTrace(); } } }

File Copy with Transfer

public class FileCopyExample { public static void main(String[] args) { Path sourcePath = Paths.get("source.txt"); Path destPath = Paths.get("destination.txt"); try (FileChannel sourceChannel = FileChannel.open(sourcePath, StandardOpenOption.READ); FileChannel destChannel = FileChannel.open(destPath, StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) { // Efficient file transfer (uses OS-level zero-copy when possible) long position = 0; long size = sourceChannel.size(); while (position < size) { position += sourceChannel.transferTo(position, size - position, destChannel); } System.out.println("File copied successfully"); } catch (IOException e) { e.printStackTrace(); } } }

SocketChannel Examples

Non-blocking Client

public class NIOClient { public static void main(String[] args) { try (SocketChannel socketChannel = SocketChannel.open()) { // Configure non-blocking mode socketChannel.configureBlocking(false); // Connect to server socketChannel.connect(new InetSocketAddress("localhost", 8080)); // Wait for connection to complete while (!socketChannel.finishConnect()) { System.out.println("Still connecting..."); Thread.sleep(1000); } // Send data String message = "Hello from NIO Client!"; ByteBuffer buffer = ByteBuffer.wrap(message.getBytes()); while (buffer.hasRemaining()) { socketChannel.write(buffer); } System.out.println("Message sent to server"); // Read response buffer.clear(); StringBuilder response = new StringBuilder(); while (socketChannel.read(buffer) > 0) { buffer.flip(); while (buffer.hasRemaining()) { response.append((char) buffer.get()); } buffer.clear(); } System.out.println("Server response: " + response.toString()); } catch (IOException | InterruptedException e) { e.printStackTrace(); } } }

5. Selectors

Selectors allow a single thread to handle multiple channels.

Server with Selector

public class NIOServer { private Selector selector; private ServerSocketChannel serverChannel; public void start(int port) throws IOException { // Create selector selector = Selector.open(); // Create server socket channel serverChannel = ServerSocketChannel.open(); serverChannel.configureBlocking(false); serverChannel.bind(new InetSocketAddress(port)); // Register server channel with selector for accept events serverChannel.register(selector, SelectionKey.OP_ACCEPT); System.out.println("Server started on port " + port); // Event loop while (true) { // Wait for events (blocks until at least one event occurs) int readyChannels = selector.select(); if (readyChannels == 0) continue; // Process selected keys Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) { SelectionKey key = keyIterator.next(); if (key.isAcceptable()) { acceptConnection(key); } else if (key.isReadable()) { readData(key); } else if (key.isWritable()) { writeData(key); } keyIterator.remove(); } } } private void acceptConnection(SelectionKey key) throws IOException { ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); SocketChannel clientChannel = serverChannel.accept(); clientChannel.configureBlocking(false); // Register client channel for read operations clientChannel.register(selector, SelectionKey.OP_READ); System.out.println("Client connected: " + clientChannel.getRemoteAddress()); } private void readData(SelectionKey key) throws IOException { SocketChannel clientChannel = (SocketChannel) key.channel(); ByteBuffer buffer = ByteBuffer.allocate(1024); int bytesRead = clientChannel.read(buffer); if (bytesRead == -1) { // Connection closed clientChannel.close(); System.out.println("Client disconnected"); return; } if (bytesRead > 0) { buffer.flip(); byte[] data = new byte[buffer.remaining()]; buffer.get(data); String message = new String(data); System.out.println("Received: " + message); // Echo back the message ByteBuffer response = ByteBuffer.wrap(("Echo: " + message).getBytes()); clientChannel.write(response); } } private void writeData(SelectionKey key) throws IOException { // Handle write operations SocketChannel clientChannel = (SocketChannel) key.channel(); // Write logic here } public static void main(String[] args) { try { new NIOServer().start(8080); } catch (IOException e) { e.printStackTrace(); } } }

6. java.nio.file Package

Path Operations

public class PathOperations { public static void main(String[] args) { // Creating Path objects Path path1 = Paths.get("/home/user/documents/file.txt"); Path path2 = Paths.get("C:", "Users", "John", "file.txt"); Path path3 = Paths.get("relative/path/file.txt"); // Path information System.out.println("File name: " + path1.getFileName()); System.out.println("Parent: " + path1.getParent()); System.out.println("Root: " + path1.getRoot()); System.out.println("Name count: " + path1.getNameCount()); // Path navigation Path subPath = path1.subpath(1, 3); System.out.println("Subpath: " + subPath); // Resolving paths Path base = Paths.get("/base"); Path relative = Paths.get("subdir/file.txt"); Path resolved = base.resolve(relative); System.out.println("Resolved: " + resolved); // Normalizing paths Path withDots = Paths.get("/home/./user/../john/file.txt"); Path normalized = withDots.normalize(); System.out.println("Normalized: " + normalized); } }

Files Utility Class

public class FilesExamples { public static void main(String[] args) throws IOException { Path source = Paths.get("source.txt"); Path target = Paths.get("target.txt"); Path directory = Paths.get("testdir"); // Create directory Files.createDirectories(directory); // Create file with content Files.writeString(source, "Hello, Java NIO Files!", StandardOpenOption.CREATE); // Copy file Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING); // Read file content String content = Files.readString(target); System.out.println("File content: " + content); // File attributes System.out.println("Size: " + Files.size(target) + " bytes"); System.out.println("Last modified: " + Files.getLastModifiedTime(target)); System.out.println("Is readable: " + Files.isReadable(target)); // List directory contents Files.createDirectories(Paths.get("testdir/subdir")); Files.writeString(Paths.get("testdir/file1.txt"), "File 1"); Files.writeString(Paths.get("testdir/file2.txt"), "File 2"); try (Stream<Path> stream = Files.list(directory)) { stream.forEach(System.out::println); } // Walk directory tree System.out.println("\nWalking directory tree:"); Files.walk(directory) .forEach(System.out::println); } }

File Watching Service

public class FileWatcherExample { public static void main(String[] args) throws IOException, InterruptedException { WatchService watchService = FileSystems.getDefault().newWatchService(); Path directory = Paths.get("."); // Register for create, modify, and delete events directory.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE); System.out.println("Watching directory: " + directory.toAbsolutePath()); while (true) { WatchKey key = watchService.take(); // Blocks until event occurs for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind<?> kind = event.kind(); Path fileName = (Path) event.context(); System.out.println(kind + ": " + fileName); if (kind == StandardWatchEventKinds.OVERFLOW) { continue; } } // Reset the key to receive further events boolean valid = key.reset(); if (!valid) { break; } } } }

7. Character Sets and Encoding

public class CharsetExample { public static void main(String[] args) { String text = "Hello, 世界!"; // Available charsets System.out.println("Available charsets:"); Charset.availableCharsets().keySet().stream() .sorted() .forEach(System.out::println); // Encoding and decoding Charset utf8 = StandardCharsets.UTF_8; Charset iso = StandardCharsets.ISO_8859_1; // Encode string to bytes ByteBuffer utf8Buffer = utf8.encode(text); ByteBuffer isoBuffer = iso.encode(text); System.out.println("\nUTF-8 bytes: " + Arrays.toString(utf8Buffer.array())); System.out.println("ISO-8859-1 bytes: " + Arrays.toString(isoBuffer.array())); // Decode bytes to string utf8Buffer.rewind(); isoBuffer.rewind(); String decodedUtf8 = utf8.decode(utf8Buffer).toString(); String decodedIso = iso.decode(isoBuffer).toString(); System.out.println("Decoded UTF-8: " + decodedUtf8); System.out.println("Decoded ISO-8859-1: " + decodedIso); // Character buffer operations CharBuffer charBuffer = CharBuffer.allocate(100); charBuffer.put("Hello, NIO!"); charBuffer.flip(); ByteBuffer byteBuffer = utf8.encode(charBuffer); System.out.println("Encoded bytes: " + byteBuffer.remaining()); } }

8. Memory-Mapped Files

public class MemoryMappedFileExample { public static void main(String[] args) throws IOException { Path filePath = Paths.get("largefile.dat"); // Create a large file for demonstration try (FileChannel channel = FileChannel.open(filePath, StandardOpenOption.CREATE, StandardOpenOption.READ, StandardOpenOption.WRITE)) { // Create a 100MB file long fileSize = 100 * 1024 * 1024; // 100MB channel.position(fileSize - 1); channel.write(ByteBuffer.wrap(new byte[1])); // Map entire file to memory MappedByteBuffer mappedBuffer = channel.map( FileChannel.MapMode.READ_WRITE, 0, fileSize); // Write data directly to memory for (int i = 0; i < 1000; i++) { mappedBuffer.putInt(i); } // Read data from memory mappedBuffer.flip(); for (int i = 0; i < 10; i++) { System.out.println("Read: " + mappedBuffer.getInt()); } // Force changes to disk mappedBuffer.force(); } catch (IOException e) { e.printStackTrace(); } } }

9. Asynchronous File Channel

public class AsyncFileChannelExample { public static void main(String[] args) throws IOException, ExecutionException, InterruptedException { Path path = Paths.get("async_test.txt"); // Create file and write some content Files.writeString(path, "Initial content\n", StandardOpenOption.CREATE); try (AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open( path, StandardOpenOption.READ, StandardOpenOption.WRITE)) { // Asynchronous write String data = "Hello, Async NIO!\n"; ByteBuffer writeBuffer = ByteBuffer.wrap(data.getBytes()); Future<Integer> writeResult = asyncChannel.write(writeBuffer, 0); // Do other work while writing... System.out.println("Doing other work while writing..."); // Wait for write to complete Integer bytesWritten = writeResult.get(); System.out.println("Bytes written: " + bytesWritten); // Asynchronous read ByteBuffer readBuffer = ByteBuffer.allocate(1024); Future<Integer> readResult = asyncChannel.read(readBuffer, 0); // Do other work while reading... System.out.println("Doing other work while reading..."); Integer bytesRead = readResult.get(); readBuffer.flip(); byte[] readData = new byte[bytesRead]; readBuffer.get(readData); System.out.println("Read data: " + new String(readData)); } catch (IOException e) { e.printStackTrace(); } } }

10. Best Practices and Performance Tips

1. Use Direct Buffers for Large I/O Operations

// Good for large files ByteBuffer buffer = ByteBuffer.allocateDirect(8192); // Good for small, frequent allocations ByteBuffer buffer = ByteBuffer.allocate(1024);

2. Reuse Buffers

public class BufferPool { private final Queue<ByteBuffer> bufferPool = new ConcurrentLinkedQueue<>(); public ByteBuffer getBuffer(int size) { ByteBuffer buffer = bufferPool.poll(); if (buffer == null || buffer.capacity() < size) { return ByteBuffer.allocate(size); } buffer.clear(); return buffer; } public void returnBuffer(ByteBuffer buffer) { buffer.clear(); bufferPool.offer(buffer); } }

3. Proper Buffer Management

public class BufferManagement { public static void processFile(Path path) throws IOException { try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) { ByteBuffer buffer = ByteBuffer.allocateDirect(8192); while (channel.read(buffer) != -1) { buffer.flip(); // Switch to read mode processBuffer(buffer); buffer.compact(); // Keep unread data and prepare for next read } // Process any remaining data buffer.flip(); if (buffer.hasRemaining()) { processBuffer(buffer); } } } private static void processBuffer(ByteBuffer buffer) { while (buffer.hasRemaining()) { // Process each byte byte b = buffer.get(); // ... processing logic } } }

Summary

Java NIO Advantages:

Non-blocking I/O for better scalability
Memory-mapped files for high-performance file access
Selectors for handling multiple channels with single thread
Buffer-oriented operations for efficient data handling

When to Use NIO:

High-performance server applications
Large file processing
Applications requiring non-blocking I/O
Network applications with many concurrent connections

When to Use Traditional I/O:

Simple file operations
Sequential processing
When simplicity is more important than performance
Small-scale applications