Path and Files API in NIO.2 in Java

Introduction to NIO.2

Java NIO.2 (New I/O 2), introduced in Java 7, revolutionized file I/O operations with the java.nio.file package. It provides enhanced file system support, improved performance, and more intuitive APIs compared to the legacy java.io.File class.

Core Components of NIO.2

1. Path Interface

The Path interface is the cornerstone of NIO.2, representing a hierarchical path in the file system.

2. Files Class

A utility class providing static methods for file operations like read, write, copy, delete, and file attribute manipulation.

3. FileSystem and FileSystems

Classes for interacting with different file system providers.

Path Interface in Depth

Creating Path Objects

import java.nio.file.Path;
import java.nio.file.Paths;
public class PathCreation {
public static void main(String[] args) {
// Different ways to create Path objects
Path path1 = Paths.get("example.txt");
Path path2 = Paths.get("/home/user/documents", "file.txt");
Path path3 = Paths.get("/", "home", "user", "documents", "file.txt");
// Using FileSystems (less common)
Path path4 = FileSystems.getDefault().getPath("example.txt");
System.out.println("Path1: " + path1);
System.out.println("Path2: " + path2);
System.out.println("Path3: " + path3);
}
}

Path Operations and Manipulation

import java.nio.file.Path;
import java.nio.file.Paths;
public class PathOperations {
public static void main(String[] args) {
Path basePath = Paths.get("/home/user/documents");
// Resolving paths
Path resolvedPath = basePath.resolve("subfolder/file.txt");
System.out.println("Resolved: " + resolvedPath);
// Getting parent directory
Path parent = resolvedPath.getParent();
System.out.println("Parent: " + parent);
// Getting file name
Path fileName = resolvedPath.getFileName();
System.out.println("File Name: " + fileName);
// Getting root component
Path root = resolvedPath.getRoot();
System.out.println("Root: " + root);
// Normalizing paths (removing redundant elements)
Path complexPath = Paths.get("/home/user/./documents/../files");
Path normalized = complexPath.normalize();
System.out.println("Normalized: " + normalized);
// Relativizing paths
Path pathA = Paths.get("/home/user");
Path pathB = Paths.get("/home/user/documents/file.txt");
Path relative = pathA.relativize(pathB);
System.out.println("Relative path: " + relative);
// Checking absolute paths
System.out.println("Is absolute: " + resolvedPath.isAbsolute());
// Converting to absolute path
Path absolute = path1.toAbsolutePath();
System.out.println("Absolute: " + absolute);
}
}

Files Class - Comprehensive File Operations

Basic File Operations

import java.nio.file.*;
import java.io.IOException;
import java.util.List;
public class BasicFileOperations {
public static void main(String[] args) {
Path filePath = Paths.get("example.txt");
Path targetPath = Paths.get("copy_example.txt");
try {
// Check if file exists
boolean exists = Files.exists(filePath);
System.out.println("File exists: " + exists);
// Check if not exists
boolean notExists = Files.notExists(filePath);
System.out.println("File not exists: " + notExists);
// Check if readable/writable/executable
boolean readable = Files.isReadable(filePath);
boolean writable = Files.isWritable(filePath);
boolean executable = Files.isExecutable(filePath);
System.out.printf("Readable: %s, Writable: %s, Executable: %s%n", 
readable, writable, executable);
// Check if directory
boolean isDirectory = Files.isDirectory(filePath);
System.out.println("Is directory: " + isDirectory);
// Check if regular file
boolean isRegularFile = Files.isRegularFile(filePath);
System.out.println("Is regular file: " + isRegularFile);
} catch (Exception e) {
e.printStackTrace();
}
}
}

File Creation and Deletion

import java.nio.file.*;
import java.io.IOException;
import java.util.Arrays;
public class FileCreationDeletion {
public static void main(String[] args) {
try {
// Create a file
Path newFile = Paths.get("newfile.txt");
if (!Files.exists(newFile)) {
Files.createFile(newFile);
System.out.println("File created: " + newFile);
}
// Create directories
Path directories = Paths.get("parent/child/grandchild");
Files.createDirectories(directories); // Creates all intermediate directories
System.out.println("Directories created: " + directories);
// Create a file in the new directory
Path fileInDir = directories.resolve("nested.txt");
Files.createFile(fileInDir);
// Delete a file
Files.deleteIfExists(Paths.get("tobedeleted.txt"));
// List directory contents
Path currentDir = Paths.get(".");
System.out.println("\nDirectory contents:");
Files.list(currentDir)
.forEach(path -> System.out.println("  " + path));
} catch (IOException e) {
e.printStackTrace();
}
}
}

File Reading and Writing

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Arrays;
public class FileReadWrite {
public static void main(String[] args) {
Path filePath = Paths.get("sample.txt");
try {
// Writing to a file
List<String> lines = Arrays.asList(
"Line 1: Hello World",
"Line 2: Java NIO.2",
"Line 3: Files API Demo"
);
Files.write(filePath, lines, StandardCharsets.UTF_8);
System.out.println("File written successfully");
// Reading all lines
System.out.println("\nReading all lines:");
List<String> readLines = Files.readAllLines(filePath, StandardCharsets.UTF_8);
readLines.forEach(System.out::println);
// Reading as a single string
String content = new String(Files.readAllBytes(filePath), StandardCharsets.UTF_8);
System.out.println("\nFile content as single string:");
System.out.println(content);
// Appending to a file
Files.write(filePath, 
Arrays.asList("Line 4: Appended content"), 
StandardCharsets.UTF_8,
StandardOpenOption.APPEND);
System.out.println("\nAfter appending:");
Files.readAllLines(filePath, StandardCharsets.UTF_8)
.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
}
}

File Copying and Moving

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class FileCopyMove {
public static void main(String[] args) {
try {
// Create source file
Path source = Paths.get("source.txt");
Files.write(source, 
Arrays.asList("Source file content"), 
StandardCharsets.UTF_8);
// Copy file
Path copy = Paths.get("copy.txt");
Files.copy(source, copy, StandardCopyOption.REPLACE_EXISTING);
System.out.println("File copied: " + copy);
// Move/Rename file
Path moved = Paths.get("moved.txt");
Files.move(copy, moved, StandardCopyOption.REPLACE_EXISTING);
System.out.println("File moved: " + moved);
// Copy with attributes
Path copyWithAttributes = Paths.get("copy_with_attrs.txt");
Files.copy(source, copyWithAttributes, 
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES);
// Demonstrate directory copy
Path sourceDir = Paths.get("source_dir");
Path targetDir = Paths.get("target_dir");
Files.createDirectories(sourceDir);
Files.createFile(sourceDir.resolve("file1.txt"));
Files.createFile(sourceDir.resolve("file2.txt"));
// Copy entire directory
copyDirectory(sourceDir, targetDir);
} catch (IOException e) {
e.printStackTrace();
}
}
private static void copyDirectory(Path source, Path target) throws IOException {
Files.walk(source)
.forEach(sourcePath -> {
Path targetPath = target.resolve(source.relativize(sourcePath));
try {
if (Files.isDirectory(sourcePath)) {
Files.createDirectories(targetPath);
} else {
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
}

Advanced File Operations

File Attributes

import java.nio.file.*;
import java.io.IOException;
import java.nio.attribute.*;
import java.util.Set;
public class FileAttributes {
public static void main(String[] args) {
Path filePath = Paths.get("attributes_demo.txt");
try {
Files.createFile(filePath);
// Basic file attributes
BasicFileAttributes basicAttrs = Files.readAttributes(filePath, BasicFileAttributes.class);
System.out.println("Creation Time: " + basicAttrs.creationTime());
System.out.println("Last Modified: " + basicAttrs.lastModifiedTime());
System.out.println("Last Access: " + basicAttrs.lastAccessTime());
System.out.println("Is Directory: " + basicAttrs.isDirectory());
System.out.println("Size: " + basicAttrs.size() + " bytes");
// POSIX file attributes (Unix/Linux)
if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) {
PosixFileAttributes posixAttrs = Files.readAttributes(filePath, PosixFileAttributes.class);
System.out.println("Owner: " + posixAttrs.owner().getName());
System.out.println("Group: " + posixAttrs.group().getName());
System.out.println("Permissions: " + posixAttrs.permissions());
}
// Setting file permissions
Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-r--r--");
Files.setPosixFilePermissions(filePath, perms);
// DOS file attributes (Windows)
if (FileSystems.getDefault().supportedFileAttributeViews().contains("dos")) {
DosFileAttributes dosAttrs = Files.readAttributes(filePath, DosFileAttributes.class);
System.out.println("Is Hidden: " + dosAttrs.isHidden());
System.out.println("Is Archive: " + dosAttrs.isArchive());
System.out.println("Is Read-only: " + dosAttrs.isReadOnly());
System.out.println("Is System: " + dosAttrs.isSystem());
}
// Setting last modified time
FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
Files.setLastModifiedTime(filePath, newTime);
} catch (IOException e) {
e.printStackTrace();
} catch (UnsupportedOperationException e) {
System.out.println("Operation not supported on this platform: " + e.getMessage());
}
}
}

Directory Walking and File Searching

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;
public class DirectoryWalking {
public static void main(String[] args) {
Path startDir = Paths.get(".");
try {
// Walk through directory tree
System.out.println("Walking directory tree:");
Files.walk(startDir)
.filter(Files::isRegularFile)
.forEach(path -> {
try {
System.out.println("File: " + path + 
" Size: " + Files.size(path) + " bytes");
} catch (IOException e) {
System.err.println("Error reading file: " + path);
}
});
// Find files using pattern matching
System.out.println("\nFinding Java files:");
PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**.java");
Files.find(startDir, 
Integer.MAX_VALUE, 
(path, attrs) -> matcher.matches(path) && attrs.isRegularFile())
.forEach(System.out::println);
// List directory contents with DirectoryStream
System.out.println("\nDirectory contents (max depth 2):");
try (Stream<Path> paths = Files.walk(startDir, 2)) {
paths.forEach(path -> {
String type = Files.isDirectory(path) ? "DIR " : "FILE";
System.out.println(type + " " + path);
});
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

Temporary Files and Directories

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class TemporaryFiles {
public static void main(String[] args) {
try {
// Create temporary file
Path tempFile = Files.createTempFile("prefix_", "_suffix.txt");
System.out.println("Temporary file: " + tempFile);
// Write to temporary file
Files.write(tempFile, 
"Temporary file content".getBytes(StandardCharsets.UTF_8));
// Create temporary directory
Path tempDir = Files.createTempDirectory("temp_dir_");
System.out.println("Temporary directory: " + tempDir);
// Create file in temporary directory
Path fileInTempDir = tempDir.resolve("temp_file.txt");
Files.createFile(fileInTempDir);
// List temporary directory contents
System.out.println("Temporary directory contents:");
Files.list(tempDir).forEach(System.out::println);
// Note: Temporary files are not automatically deleted
// You need to manually delete them or use deleteOnExit()
tempFile.toFile().deleteOnExit();
fileInTempDir.toFile().deleteOnExit();
tempDir.toFile().deleteOnExit();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Practical Examples and Use Cases

File Monitoring with WatchService

import java.nio.file.*;
import java.io.IOException;
import static java.nio.file.StandardWatchEventKinds.*;
public class FileWatcher {
public static void main(String[] args) {
Path watchDir = Paths.get(".");
try {
WatchService watchService = FileSystems.getDefault().newWatchService();
// Register for events
watchDir.register(watchService, 
ENTRY_CREATE, 
ENTRY_DELETE, 
ENTRY_MODIFY);
System.out.println("Watching directory: " + watchDir.toAbsolutePath());
System.out.println("Press Ctrl+C to stop...");
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 == ENTRY_CREATE) {
System.out.println("  New file created: " + fileName);
} else if (kind == ENTRY_MODIFY) {
System.out.println("  File modified: " + fileName);
} else if (kind == ENTRY_DELETE) {
System.out.println("  File deleted: " + fileName);
}
}
boolean valid = key.reset();
if (!valid) {
break;
}
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}

File Utility Class

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;
public class FileUtils {
// Read file content as string
public static String readFile(Path filePath) throws IOException {
return new String(Files.readAllBytes(filePath), StandardCharsets.UTF_8);
}
// Write string to file
public static void writeFile(Path filePath, String content) throws IOException {
Files.write(filePath, content.getBytes(StandardCharsets.UTF_8));
}
// Find files by extension
public static List<Path> findFilesByExtension(Path startDir, String extension) 
throws IOException {
String pattern = "glob:**." + extension;
PathMatcher matcher = FileSystems.getDefault().getPathMatcher(pattern);
return Files.walk(startDir)
.filter(path -> matcher.matches(path) && Files.isRegularFile(path))
.collect(Collectors.toList());
}
// Copy directory recursively
public static void copyDirectoryRecursive(Path source, Path target) throws IOException {
Files.walk(source)
.forEach(sourcePath -> {
Path targetPath = target.resolve(source.relativize(sourcePath));
try {
if (Files.isDirectory(sourcePath)) {
Files.createDirectories(targetPath);
} else {
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
// Get file information
public static void printFileInfo(Path filePath) throws IOException {
BasicFileAttributes attrs = Files.readAttributes(filePath, BasicFileAttributes.class);
System.out.println("File: " + filePath);
System.out.println("Size: " + attrs.size() + " bytes");
System.out.println("Created: " + attrs.creationTime());
System.out.println("Modified: " + attrs.lastModifiedTime());
System.out.println("Is Directory: " + attrs.isDirectory());
System.out.println("Is Regular File: " + attrs.isRegularFile());
}
public static void main(String[] args) {
try {
// Demonstrate utility methods
Path testFile = Paths.get("test_utility.txt");
writeFile(testFile, "Utility class demonstration");
String content = readFile(testFile);
System.out.println("File content: " + content);
printFileInfo(testFile);
// Clean up
Files.deleteIfExists(testFile);
} catch (IOException e) {
e.printStackTrace();
}
}
}

Error Handling and Best Practices

Proper Exception Handling

import java.nio.file.*;
import java.io.IOException;
public class ErrorHandling {
public static void main(String[] args) {
Path filePath = Paths.get("nonexistent.txt");
try {
// This will throw NoSuchFileException
Files.readAllLines(filePath);
} catch (NoSuchFileException e) {
System.err.println("File does not exist: " + e.getFile());
} catch (AccessDeniedException e) {
System.err.println("Access denied: " + e.getFile());
} catch (IOException e) {
System.err.println("General I/O error: " + e.getMessage());
} finally {
System.out.println("Cleanup operations can go here");
}
}
}

Performance Considerations

1. Use Buffered Operations for Large Files

import java.nio.file.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class BufferedOperations {
// Efficient for large files
public static void processLargeFile(Path inputPath, Path outputPath) throws IOException {
try (BufferedReader reader = Files.newBufferedReader(inputPath, StandardCharsets.UTF_8);
BufferedWriter writer = Files.newBufferedWriter(outputPath, StandardCharsets.UTF_8)) {
String line;
while ((line = reader.readLine()) != null) {
// Process line
String processedLine = line.toUpperCase();
writer.write(processedLine);
writer.newLine();
}
}
}
// Using streams for binary data
public static void copyLargeFile(Path source, Path target) throws IOException {
try (InputStream in = Files.newInputStream(source);
OutputStream out = Files.newOutputStream(target)) {
byte[] buffer = new byte[8192]; // 8KB buffer
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
}
}
}

Conclusion

The NIO.2 Path and Files API provides a robust, modern approach to file system operations in Java. Key advantages include:

Type Safety: Strongly typed APIs reduce runtime errors
Performance: Better performance than legacy I/O
Flexibility: Support for multiple file systems and custom providers
Comprehensive Features: File watching, attributes, symbolic links
Stream Integration: Seamless integration with Java Streams API

When working with NIO.2:

Always handle exceptions appropriately
Use try-with-resources for automatic resource management
Consider performance implications for large files
Leverage the rich set of file attributes and metadata
Utilize the WatchService for real-time file monitoring

This powerful API makes file operations in Java more intuitive, efficient, and maintainable for modern applications.