Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java NIO (New I/O) — Path, Files, Channels, Buffers, non-blocking I/O, WatchService, and modern file operations that replace traditional java.io approaches.
What is NIO?
NIO (New I/O) was introduced in Java 1.4 (enhanced in Java 7 as NIO.2) as a modern alternative to traditional java.io. It provides:
java.nio.file.Path— replacement forjava.io.Filejava.nio.file.Files— utility methods for file operations- Channels & Buffers — for high-performance I/O
- Non-blocking I/O — for scalable network applications
- WatchService — file system monitoring
| Traditional I/O (java.io) | NIO (java.nio): |
| File | Path |
| FileInputStream | Files.newInputStream() |
| FileOutputStream | Files.newOutputStream() |
| FileReader/Writer | Files.newBufferedReader/Writer() |
| File.listFiles() | Files.list(), Files.walk() |
| File.delete() | Files.delete() |
Path — Modern File Path Handling
Example
import java.nio.file.*;
public class PathExample {
public static void main(String[] args) {
System.out.println("=== Path Examples ===\n");
// Creating paths
Path path1 = Path.of("src", "main", "java", "App.java");
Path path2 = Paths.get("C:/Users/data/report.txt"); // Alternative
Path path3 = Path.of("./data/../config/app.properties");
System.out.println("--- Path Information ---");
System.out.println("path1: " + path1);
System.out.println(" Filename: " + path1.getFileName());
System.out.println(" Parent: " + path1.getParent());
System.out.println(" Root: " + path1.getRoot());
System.out.println(" Name count: " + path1.getNameCount());
System.out.println(" Is absolute? " + path1.isAbsolute());
System.out.println("\n--- Path Resolution ---");
Path base = Path.of("/home/user");
Path relative = Path.of("documents/file.txt");
Path resolved = base.resolve(relative);
System.out.println("Base: " + base);
System.out.println("Relative: " + relative);
System.out.println("Resolved: " + resolved);
System.out.println("\n--- Normalize (remove . and ..) ---");
System.out.println("Before: " + path3);
System.out.println("After: " + path3.normalize());
System.out.println("\n--- Relativize ---");
Path p1 = Path.of("/home/user/docs");
Path p2 = Path.of("/home/user/photos/vacation");
System.out.println("From: " + p1);
System.out.println("To: " + p2);
System.out.println("Relative: " + p1.relativize(p2));
System.out.println("\n--- Iterating Path Components ---");
Path fullPath = Path.of("src/main/java/com/example/App.java");
for (int i = 0; i < fullPath.getNameCount(); i++) {
System.out.println(" [" + i + "] " + fullPath.getName(i));
}
}
}
Output:
| path1 | src/main/java/App.java |
| Filename | App.java |
| Parent | src/main/java |
| Root | null |
| Name count | 4 |
| Base | /home/user |
| Relative | documents/file.txt |
| Resolved | /home/user/documents/file.txt |
| Before | ./data/../config/app.properties |
| After | config/app.properties |
| From | /home/user/docs |
| To | /home/user/photos/vacation |
| Relative | ../../photos/vacation |
Files — Powerful File Operations
java example
import java.nio.file.*;
import java.nio.charset.StandardCharsets;
import java.io.IOException;
import java.util.List;
public class FilesExample {
public static void main(String[] args) throws IOException {
System.out.println("=== Files Utility Class ===\n");
Path file = Path.of("demo.txt");
// --- Writing ---
System.out.println("--- Writing Files ---");
// Write string (Java 11+)
Files.writeString(file, "Hello, NIO!\nLine 2\nLine 3\n");
System.out.println("✓ writeString()");
// Write lines
Path file2 = Path.of("lines.txt");
List<String> lines = List.of("First", "Second", "Third", "Fourth");
Files.write(file2, lines, StandardCharsets.UTF_8);
System.out.println("✓ write(lines)");
// Write bytes
Path binFile = Path.of("data.bin");
Files.write(binFile, new byte[]{1, 2, 3, 4, 5});
System.out.println("✓ write(bytes)");
// --- Reading ---
System.out.println("\n--- Reading Files ---");
// Read entire file as string (Java 11+)
String content = Files.readString(file);
System.out.println("readString(): " + content.trim());
// Read all lines
List<String> allLines = Files.readAllLines(file2);
System.out.println("readAllLines(): " + allLines);
// Read all bytes
byte[] bytes = Files.readAllBytes(binFile);
System.out.print("readAllBytes(): ");
for (byte b : bytes) System.out.print(b + " ");
System.out.println();
// --- File Properties ---
System.out.println("\n--- File Properties ---");
System.out.println("Size: " + Files.size(file) + " bytes");
System.out.println("Exists: " + Files.exists(file));
System.out.println("Is regular file: " + Files.isRegularFile(file));
System.out.println("Is directory: " + Files.isDirectory(file));
System.out.println("Is readable: " + Files.isReadable(file));
System.out.println("Is writable: " + Files.isWritable(file));
System.out.println("Last modified: " + Files.getLastModifiedTime(file));
// --- Copy and Move ---
System.out.println("\n--- Copy and Move ---");
Path copy = Path.of("demo_copy.txt");
Files.copy(file, copy, StandardCopyOption.REPLACE_EXISTING);
System.out.println("✓ Copied: " + file + " → " + copy);
Path moved = Path.of("demo_moved.txt");
Files.move(copy, moved, StandardCopyOption.REPLACE_EXISTING);
System.out.println("✓ Moved: " + copy + " → " + moved);
// --- Create Directories ---
System.out.println("\n--- Directories ---");
Path dirs = Path.of("output/reports/2024");
Files.createDirectories(dirs);
System.out.println("✓ Created: " + dirs);
// --- Cleanup ---
Files.deleteIfExists(file);
Files.deleteIfExists(file2);
Files.deleteIfExists(binFile);
Files.deleteIfExists(moved);
Files.deleteIfExists(Path.of("output/reports/2024"));
Files.deleteIfExists(Path.of("output/reports"));
Files.deleteIfExists(Path.of("output"));
System.out.println("\n✓ Cleanup complete");
}
}Walking Directory Trees
java example
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.stream.*;
public class DirectoryWalking {
public static void main(String[] args) throws IOException {
Path startDir = Path.of(".");
System.out.println("=== Directory Walking with NIO ===\n");
// Method 1: Files.list() — non-recursive (one level)
System.out.println("--- Files.list() (one level) ---");
try (Stream<Path> entries = Files.list(startDir)) {
entries.limit(5).forEach(p ->
System.out.println(" " + (Files.isDirectory(p) ? "📁 " : "📄 ") + p.getFileName()));
}
// Method 2: Files.walk() — recursive
System.out.println("\n--- Files.walk() (recursive) ---");
try (Stream<Path> paths = Files.walk(startDir, 2)) { // max depth 2
paths.filter(Files::isRegularFile)
.filter(p -> p.toString().endsWith(".java"))
.limit(5)
.forEach(p -> System.out.println(" " + p));
}
// Method 3: Files.find() — with attributes filter
System.out.println("\n--- Files.find() (with filter) ---");
try (Stream<Path> found = Files.find(startDir, 3,
(path, attrs) -> attrs.isRegularFile() && attrs.size() > 1000)) {
found.limit(5).forEach(p -> {
try {
System.out.printf(" %s (%d bytes)%n", p.getFileName(), Files.size(p));
} catch (IOException e) { }
});
}
// Method 4: Counting and statistics
System.out.println("\n--- File Statistics ---");
try (Stream<Path> paths = Files.walk(startDir, 3)) {
var stats = paths.filter(Files::isRegularFile)
.collect(Collectors.groupingBy(
p -> getExtension(p.toString()),
Collectors.counting()));
stats.entrySet().stream()
.sorted((a, b) -> Long.compare(b.getValue(), a.getValue()))
.limit(5)
.forEach(e -> System.out.printf(" .%-6s : %d files%n", e.getKey(), e.getValue()));
}
}
static String getExtension(String filename) {
int dot = filename.lastIndexOf('.');
return dot == -1 ? "none" : filename.substring(dot + 1);
}
}Channels and Buffers
NIO introduces a channel-based I/O model using Buffers:
Example
import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;
import java.io.*;
public class ChannelBufferExample {
public static void main(String[] args) throws IOException {
System.out.println("=== Channels and Buffers ===\n");
// Write using FileChannel
Path file = Path.of("channel_test.txt");
try (FileChannel channel = FileChannel.open(file,
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
String data = "Hello from NIO Channels! This is efficient I/O.";
ByteBuffer buffer = ByteBuffer.wrap(data.getBytes());
channel.write(buffer);
System.out.println("✓ Written via FileChannel: " + data.length() + " bytes");
}
// Read using FileChannel
try (FileChannel channel = FileChannel.open(file, StandardOpenOption.READ)) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
buffer.flip(); // Switch from write mode to read mode
byte[] bytes = new byte[bytesRead];
buffer.get(bytes);
System.out.println("✓ Read via FileChannel: " + new String(bytes));
}
// ByteBuffer operations
System.out.println("\n--- ByteBuffer Operations ---");
ByteBuffer buf = ByteBuffer.allocate(20);
System.out.println("Capacity: " + buf.capacity());
System.out.println("Position: " + buf.position());
System.out.println("Limit: " + buf.limit());
buf.putInt(42);
buf.putDouble(3.14);
System.out.println("\nAfter putting int + double:");
System.out.println("Position: " + buf.position()); // 4 + 8 = 12
buf.flip(); // Prepare for reading
System.out.println("\nAfter flip (ready to read):");
System.out.println("Position: " + buf.position()); // 0
System.out.println("Limit: " + buf.limit()); // 12
System.out.println("Read int: " + buf.getInt());
System.out.println("Read double: " + buf.getDouble());
// File copy with channels (very fast)
System.out.println("\n--- Fast File Copy with Channels ---");
Path source = file;
Path dest = Path.of("channel_copy.txt");
try (FileChannel srcChannel = FileChannel.open(source, StandardOpenOption.READ);
FileChannel destChannel = FileChannel.open(dest,
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
srcChannel.transferTo(0, srcChannel.size(), destChannel);
System.out.println("✓ Copied " + srcChannel.size() + " bytes using transferTo()");
}
Files.deleteIfExists(file);
Files.deleteIfExists(dest);
}
}
Output:
| ✓ Written via FileChannel | 48 bytes |
| ✓ Read via FileChannel | Hello from NIO Channels! This is efficient I/O. |
| Capacity | 20 |
| Position | 0 |
| Limit | 20 |
| Position | 12 |
| Position | 0 |
| Limit | 12 |
| Read int | 42 |
| Read double | 3.14 |
WatchService — File System Monitoring
Example
import java.nio.file.*;
import java.io.IOException;
public class WatchServiceExample {
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("=== WatchService Demo ===\n");
// Create a directory to watch
Path watchDir = Path.of("watched_folder");
Files.createDirectories(watchDir);
// Create WatchService
WatchService watcher = FileSystems.getDefault().newWatchService();
// Register directory for events
watchDir.register(watcher,
StandardWatchEventKinds.ENTRY_CREATE,
StandardWatchEventKinds.ENTRY_DELETE,
StandardWatchEventKinds.ENTRY_MODIFY);
System.out.println("Watching: " + watchDir.toAbsolutePath());
System.out.println("(Creating test files to trigger events...)\n");
// Simulate file changes in a separate thread
new Thread(() -> {
try {
Thread.sleep(500);
Files.writeString(watchDir.resolve("test1.txt"), "Hello!");
Thread.sleep(500);
Files.writeString(watchDir.resolve("test1.txt"), "Modified!");
Thread.sleep(500);
Files.delete(watchDir.resolve("test1.txt"));
Thread.sleep(500);
} catch (Exception e) { }
}).start();
// Watch for events (with timeout)
int eventsReceived = 0;
long endTime = System.currentTimeMillis() + 3000;
while (System.currentTimeMillis() < endTime && eventsReceived < 3) {
WatchKey key = watcher.poll(500, java.util.concurrent.TimeUnit.MILLISECONDS);
if (key == null) continue;
for (WatchEvent<?> event : key.pollEvents()) {
WatchEvent.Kind<?> kind = event.kind();
Path filename = (Path) event.context();
String action = switch (kind.name()) {
case "ENTRY_CREATE" -> "📁 CREATED";
case "ENTRY_MODIFY" -> "📝 MODIFIED";
case "ENTRY_DELETE" -> "🗑️ DELETED";
default -> "❓ " + kind.name();
};
System.out.println(" " + action + ": " + filename);
eventsReceived++;
}
key.reset();
}
watcher.close();
// Cleanup
try { Files.deleteIfExists(watchDir.resolve("test1.txt")); } catch (Exception e) {}
Files.deleteIfExists(watchDir);
System.out.println("\n✓ WatchService closed. Received " + eventsReceived + " events.");
}
}
NIO vs Traditional I/O Comparison
Example
import java.io.*;
import java.nio.file.*;
import java.util.*;
public class NIOvsIO {
public static void main(String[] args) throws IOException {
System.out.println("=== NIO vs Traditional I/O ===\n");
// --- Reading a file ---
System.out.println("--- Reading a File ---");
// Old way (java.io)
System.out.println("Old (java.io):");
System.out.println(" BufferedReader br = new BufferedReader(new FileReader(file));");
System.out.println(" String line; while ((line = br.readLine()) != null) { ... }");
System.out.println(" br.close();");
// New way (java.nio)
System.out.println("New (java.nio):");
System.out.println(" String content = Files.readString(Path.of(file));");
System.out.println(" // OR");
System.out.println(" List<String> lines = Files.readAllLines(Path.of(file));");
// --- Copying a file ---
System.out.println("\n--- Copying a File ---");
System.out.println("Old: Manual stream loop with byte buffer");
System.out.println("New: Files.copy(source, target, REPLACE_EXISTING);");
// --- Deleting ---
System.out.println("\n--- Error Handling ---");
System.out.println("Old: file.delete() returns boolean (WHY did it fail?)");
System.out.println("New: Files.delete(path) throws IOException with reason!");
// Performance comparison
System.out.println("\n--- Performance Test ---");
// Create test file
Path testFile = Path.of("perf_test.txt");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append("Line ").append(i).append(": Test data for performance\n");
}
Files.writeString(testFile, sb.toString());
// Old way
long start = System.nanoTime();
try (BufferedReader br = new BufferedReader(new FileReader(testFile.toFile()))) {
while (br.readLine() != null) { }
}
long oldTime = System.nanoTime() - start;
// NIO way
start = System.nanoTime();
Files.readAllLines(testFile);
long nioTime = System.nanoTime() - start;
System.out.printf("BufferedReader: %.2f ms%n", oldTime / 1_000_000.0);
System.out.printf("Files.readAllLines: %.2f ms%n", nioTime / 1_000_000.0);
Files.deleteIfExists(testFile);
}
}
Common Mistakes
1. Not closing streams from Files methods
java example
// ❌ BAD: Stream is never closed (resource leak!)
Files.walk(Path.of(".")).forEach(System.out::println);
// ✅ GOOD: Use try-with-resources
try (Stream<Path> paths = Files.walk(Path.of("."))) {
paths.forEach(System.out::println);
}2. Using readAllBytes on huge files
java example
// ❌ BAD: Loads entire 2GB file into memory!
byte[] data = Files.readAllBytes(Path.of("huge_file.dat"));
// ✅ GOOD: Stream line by line
try (Stream<String> lines = Files.lines(Path.of("huge_file.txt"))) {
lines.filter(l -> l.contains("ERROR")).forEach(System.out::println);
}3. Forgetting to flip ByteBuffer
Example
ByteBuffer buf = ByteBuffer.allocate(100);
buf.put("Hello".getBytes());
// ❌ WRONG: Position is at end, nothing to read!
byte[] data = new byte[5];
buf.get(data); // BufferUnderflowException
// ✅ CORRECT: Flip first
buf.flip(); // position=0, limit=5
byte[] data = new byte[5];
buf.get(data); // Works!
Interview Questions
Q1: What is the difference between java.io.File and java.nio.file.Path?
Answer: File is a legacy class (Java 1.0) representing a file path. Path (Java 7) is its modern replacement offering: better error handling (exceptions with reasons vs booleans), symbolic link support, file system independence, and integration with the Files utility class. New code should always use Path.
Q2: What are Channels and Buffers in NIO?
Answer: Channels are bidirectional connections to I/O sources (files, sockets). Buffers are containers that hold data being transferred. Data flows: Channel → Buffer (read) or Buffer → Channel (write). This is more efficient than stream-based I/O because channels can use OS-level optimizations like DMA transfers.
Q3: What is the difference between blocking and non-blocking I/O?
Answer: Blocking I/O: the thread waits (blocks) until the operation completes. Non-blocking I/O (NIO): the thread can continue doing other work — it checks if data is available without waiting. This allows one thread to manage many connections (key for scalable servers).
Q4: What is WatchService used for?
Answer: WatchService monitors file system changes (create, modify, delete events) in a directory. Use cases: hot-reloading config files, auto-compiling changed source files, sync tools (like Dropbox), log file monitoring.
Q5: What are the advantages of Files.copy() over manual stream copying?
Answer: Files.copy() uses OS-level operations (like sendfile on Linux) that can transfer data without copying through user space. It handles atomic operations, preserves file attributes, supports options like REPLACE_EXISTING and COPY_ATTRIBUTES, and provides clear exceptions on failure.
Q6: Explain ByteBuffer's flip() method.
Answer: flip() prepares a buffer for reading after writing. It sets limit = position (marks the end of written data) and position = 0 (starts reading from the beginning). Without flip, you'd try to read from the current position (end of data) and get nothing.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Java NIO Package.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, file, handling, nio
Related Java Master Course Topics
Continue learning this concept
File HandlingBuffered Streams in JavaComplete guide to Buffered Streams in Java — BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, performance benefits, line-by-line reading, and real-world file processing.File HandlingByte Streams in JavaComplete guide to Byte Streams in Java — FileInputStream, FileOutputStream, reading and writing binary data, copying files, and understanding byte-level I/O operations.File HandlingCharacter Streams in JavaComplete guide to Character Streams in Java — FileReader, FileWriter, handling Unicode text, character encoding, reading/writing text files with proper internationalization support.File HandlingDeserialization in JavaComplete guide to Deserialization in Java — ObjectInputStream, reading objects from files, type safety, version compatibility, security risks, and best practices for safe deserialization.File HandlingFile Class in JavaComplete guide to the java.io.File class — creating File objects, checking file properties, creating/deleting files and directories, listing contents, and file path operations.File HandlingSerialization in JavaComplete guide to Serialization in Java — converting objects to byte streams, Serializable interface, ObjectOutputStream, transient keyword, serialVersionUID, and custom serialization.