掌握 Java NIO.2：利用 Path、Files 类操作文件系统，实现更灵活、高效的文件管理。

好的，各位观众老爷们，欢迎来到今天的“Java NIO.2 文件系统魔法秀”！我是你们的老朋友，代码界的段子手，bug界的终结者，今天就带大家一起玩转 Java NIO.2，让文件管理不再是枯燥的搬砖，而是充满乐趣的魔法冒险！🧙‍♂️

开场白：告别老旧，迎接NIO.2的春天

话说江湖多年，各位Java侠士们想必都曾被 java.io 包折磨过：同步阻塞，性能低下，代码冗长… 简直是噩梦般的存在！每次操作文件，就像蜗牛爬树，慢到让人怀疑人生。

但别担心，救星来了！Java NIO.2 带着 Path 和 Files 这两大神器，踏着七彩祥云，来拯救我们于水火之中！ NIO.2 就像是文件操作界的“钢铁侠”，赋予我们更强大、更灵活、更高效的文件管理能力。

今天，我们就一起揭开 NIO.2 的神秘面纱，让它成为你手中最得力的武器！

第一幕：Path 类的华丽登场：通往文件世界的钥匙

Path 类，就像一把通往文件世界的钥匙，它代表着文件系统中的一个路径。不再是 File 类那种模棱两可的抽象，Path 类更加清晰、明确，功能也更加强大。

1. 创建 Path 对象：条条大路通罗马，路径创建任你选

创建 Path 对象的方式多种多样，总有一款适合你：

Paths.get(String pathname)： 最简单粗暴的方式，直接用字符串创建路径。

Path path1 = Paths.get("C:/myproject/data.txt"); // Windows
Path path2 = Paths.get("/home/user/documents/report.pdf"); // Linux/macOS

Paths.get(String first, String... more)： 将多个字符串拼接成路径。

Path path3 = Paths.get("C:", "myproject", "data", "config.xml"); // Windows
Path path4 = Paths.get("/home", "user", "documents", "images", "logo.png"); // Linux/macOS

Path.of(String first, String... more)： JDK 11 引入的更简洁的写法，功能与Paths.get类似。

Path path5 = Path.of("C:", "myproject", "data", "config.xml");
Path path6 = Path.of("/home", "user", "documents", "images", "logo.png");

FileSystem.getPath(String first, String... more)： 可以指定文件系统，例如 ZIP 文件系统。这个高级用法我们稍后会讲到。

2. Path 对象的常用方法：十八般武艺，样样精通

Path 对象就像一个百宝箱，里面装满了各种实用的方法，助你轻松玩转文件路径。

方法名	功能描述	示例
`getFileName()`	获取路径的最后一个元素（文件名或目录名）	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.getFileName(); // 返回 "report.pdf"`
`getParent()`	获取路径的父路径	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.getParent(); // 返回 "/home/user/documents"`
`getRoot()`	获取路径的根路径	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.getRoot(); // 返回 "/"` (Linux/macOS) `Path path = Paths.get("C:/myproject/data.txt");` `path.getRoot(); // 返回 "C:"` (Windows)
`getNameCount()`	获取路径中元素的个数（不包括根路径）	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.getNameCount(); // 返回 3` (home, user, documents)
`getName(int index)`	获取路径中指定索引位置的元素	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.getName(0); // 返回 "home"`
`subpath(int beginIndex, int endIndex)`	获取路径中指定范围的子路径	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.subpath(0, 2); // 返回 "home/user"`
`isAbsolute()`	判断路径是否为绝对路径	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.isAbsolute(); // 返回 true` `Path path = Paths.get("data/report.pdf");` `path.isAbsolute(); // 返回 false`
`toAbsolutePath()`	获取路径的绝对路径	`Path path = Paths.get("data/report.pdf");` `path.toAbsolutePath(); // 返回 "/current/working/directory/data/report.pdf"`
`normalize()`	规范化路径（移除冗余的 "." 和 ".."）	`Path path = Paths.get("/home/user/../documents/./report.pdf");` `path.normalize(); // 返回 "/home/documents/report.pdf"`
`resolve(Path other)`	将 other 路径解析到当前路径	`Path path1 = Paths.get("/home/user");` `Path path2 = Paths.get("documents/report.pdf");` `path1.resolve(path2); // 返回 "/home/user/documents/report.pdf"`
`resolveSibling(Path other)`	将 other 路径解析到当前路径的父路径	`Path path1 = Paths.get("/home/user/documents/report.pdf");` `Path path2 = Paths.get("config.xml");` `path1.resolveSibling(path2); // 返回 "/home/user/config.xml"`
`relativize(Path other)`	获取当前路径到 other 路径的相对路径	`Path path1 = Paths.get("/home/user");` `Path path2 = Paths.get("/home/user/documents/report.pdf");` `path1.relativize(path2); // 返回 "documents/report.pdf"`
`startsWith(Path other)`	判断路径是否以 other 路径开头	`Path path1 = Paths.get("/home/user/documents/report.pdf");` `Path path2 = Paths.get("/home/user");` `path1.startsWith(path2); // 返回 true`
`endsWith(Path other)`	判断路径是否以 other 路径结尾	`Path path1 = Paths.get("/home/user/documents/report.pdf");` `Path path2 = Paths.get("report.pdf");` `path1.endsWith(path2); // 返回 true`
`toUri()`	将路径转换为 URI	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.toUri(); // 返回 "file:///home/user/documents/report.pdf"`
`toFile()`	将路径转换为 File 对象（与旧 API 兼容）	`Path path = Paths.get("/home/user/documents/report.pdf");` `path.toFile(); // 返回一个 File 对象`

重点提示：

resolve() 和 resolveSibling() 的区别：resolve() 是将 other 路径直接拼接到当前路径之后，而 resolveSibling() 是将 other 路径拼接到当前路径的父路径之后。
relativize() 的作用：计算两个路径之间的相对关系，这在构建可移植的应用程序时非常有用。

3. Path 的比较：路径比大小，清晰又明了

Path 对象可以使用 equals() 方法进行比较，判断两个路径是否相等。另外，还可以使用 compareTo() 方法进行比较，判断两个路径的字典顺序。

Path path1 = Paths.get("/home/user/documents/report.pdf");
Path path2 = Paths.get("/home/user/documents/report.pdf");
Path path3 = Paths.get("/home/user/documents/config.xml");

System.out.println(path1.equals(path2)); // true
System.out.println(path1.equals(path3)); // false

System.out.println(path1.compareTo(path3)); // 大于 0 (因为 report.pdf 的字典顺序在 config.xml 之后)

第二幕：Files 类的魔法表演：文件操作，信手拈来

Files 类是 NIO.2 中文件操作的核心类，它提供了大量的静态方法，用于创建、删除、复制、移动、读取、写入文件等操作。就像一位技艺精湛的魔术师，Files 类能变幻出各种文件操作的戏法。

1. 文件和目录的创建与删除：乾坤大挪移，文件随心变

Files.createFile(Path path, FileAttribute<?>... attrs)： 创建一个新文件。

Path newFile = Paths.get("C:/myproject/new_file.txt");
try {
    Files.createFile(newFile);
    System.out.println("文件创建成功！");
} catch (IOException e) {
    System.err.println("文件创建失败：" + e.getMessage());
}

Files.createDirectory(Path dir, FileAttribute<?>... attrs)： 创建一个新目录。

Path newDir = Paths.get("C:/myproject/new_directory");
try {
    Files.createDirectory(newDir);
    System.out.println("目录创建成功！");
} catch (IOException e) {
    System.err.println("目录创建失败：" + e.getMessage());
}

Files.createDirectories(Path dir, FileAttribute<?>... attrs)： 创建多层目录。如果父目录不存在，会自动创建。

Path newDirs = Paths.get("C:/myproject/level1/level2/level3");
try {
    Files.createDirectories(newDirs);
    System.out.println("多层目录创建成功！");
} catch (IOException e) {
    System.err.println("多层目录创建失败：" + e.getMessage());
}

Files.delete(Path path)： 删除文件或空目录。

Path fileToDelete = Paths.get("C:/myproject/new_file.txt");
try {
    Files.delete(fileToDelete);
    System.out.println("文件删除成功！");
} catch (IOException e) {
    System.err.println("文件删除失败：" + e.getMessage());
}

Files.deleteIfExists(Path path)： 删除文件或空目录，如果不存在则忽略。

Path fileToDelete = Paths.get("C:/myproject/non_existent_file.txt");
try {
    boolean deleted = Files.deleteIfExists(fileToDelete);
    if (deleted) {
        System.out.println("文件删除成功！");
    } else {
        System.out.println("文件不存在，无需删除。");
    }
} catch (IOException e) {
    System.err.println("文件删除失败：" + e.getMessage());
}

2. 文件和目录的复制与移动：移形换影，文件大搬家

Files.copy(Path source, Path target, CopyOption... options)： 复制文件或目录。
```
Path sourceFile = Paths.get("C:/myproject/source.txt");
Path targetFile = Paths.get("C:/myproject/backup/source.txt");
try {
    Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING); // 替换已存在的文件
    System.out.println("文件复制成功！");
} catch (IOException e) {
    System.err.println("文件复制失败：" + e.getMessage());
}
```
CopyOption 的常用选项：
- StandardCopyOption.REPLACE_EXISTING：如果目标文件已存在，则替换它。
- StandardCopyOption.COPY_ATTRIBUTES：复制文件属性（例如，最后修改时间）。
- LinkOption.NOFOLLOW_LINKS：如果源文件是符号链接，则复制链接本身，而不是链接指向的文件。

Files.move(Path source, Path target, CopyOption... options)： 移动文件或目录。

Path sourceFile = Paths.get("C:/myproject/source.txt");
Path targetFile = Paths.get("C:/myproject/moved/source.txt");
try {
    Files.move(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING); // 替换已存在的文件
    System.out.println("文件移动成功！");
} catch (IOException e) {
    System.err.println("文件移动失败：" + e.getMessage());
}

CopyOption 的常用选项：

StandardCopyOption.ATOMIC_MOVE：尝试原子性地移动文件（并非所有文件系统都支持）。

3. 文件的读取与写入：妙笔生花，数据任你写

Files.readAllBytes(Path path)： 将整个文件读取到字节数组中。

Path fileToRead = Paths.get("C:/myproject/data.txt");
try {
    byte[] bytes = Files.readAllBytes(fileToRead);
    String content = new String(bytes);
    System.out.println("文件内容：" + content);
} catch (IOException e) {
    System.err.println("文件读取失败：" + e.getMessage());
}

Files.readAllLines(Path path, Charset cs)： 将整个文件读取到字符串列表中，每行一个元素。

Path fileToRead = Paths.get("C:/myproject/data.txt");
try {
    List<String> lines = Files.readAllLines(fileToRead, StandardCharsets.UTF_8);
    for (String line : lines) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.err.println("文件读取失败：" + e.getMessage());
}

Files.write(Path path, byte[] bytes, OpenOption... options)： 将字节数组写入文件。

Path fileToWrite = Paths.get("C:/myproject/output.txt");
String content = "Hello, NIO.2!";
byte[] bytes = content.getBytes();
try {
    Files.write(fileToWrite, bytes, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING); // 创建文件并覆盖原有内容
    System.out.println("文件写入成功！");
} catch (IOException e) {
    System.err.println("文件写入失败：" + e.getMessage());
}

Files.write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)： 将字符串列表写入文件，每行一个元素。
```
Path fileToWrite = Paths.get("C:/myproject/output.txt");
List<String> lines = Arrays.asList("Line 1", "Line 2", "Line 3");
try {
    Files.write(fileToWrite, lines, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING); // 创建文件并覆盖原有内容
    System.out.println("文件写入成功！");
} catch (IOException e) {
    System.err.println("文件写入失败：" + e.getMessage());
}
```
OpenOption 的常用选项：
- StandardOpenOption.CREATE：如果文件不存在，则创建它。
- StandardOpenOption.TRUNCATE_EXISTING：如果文件已存在，则将其截断为零长度。
- StandardOpenOption.APPEND：将数据追加到文件末尾。
- StandardOpenOption.WRITE：打开文件进行写入。
- StandardOpenOption.READ：打开文件进行读取。

4. 文件的属性：知根知底，文件信息全掌握

Files.size(Path path)： 获取文件的大小（字节数）。

Path fileToCheck = Paths.get("C:/myproject/data.txt");
try {
    long size = Files.size(fileToCheck);
    System.out.println("文件大小：" + size + " 字节");
} catch (IOException e) {
    System.err.println("获取文件大小失败：" + e.getMessage());
}

Files.getLastModifiedTime(Path path, LinkOption... options)： 获取文件的最后修改时间。

Path fileToCheck = Paths.get("C:/myproject/data.txt");
try {
    FileTime lastModifiedTime = Files.getLastModifiedTime(fileToCheck);
    System.out.println("最后修改时间：" + lastModifiedTime);
} catch (IOException e) {
    System.err.println("获取最后修改时间失败：" + e.getMessage());
}

Files.setLastModifiedTime(Path path, FileTime time)： 设置文件的最后修改时间。

Path fileToUpdate = Paths.get("C:/myproject/data.txt");
FileTime newTime = FileTime.from(Instant.now());
try {
    Files.setLastModifiedTime(fileToUpdate, newTime);
    System.out.println("最后修改时间设置成功！");
} catch (IOException e) {
    System.err.println("设置最后修改时间失败：" + e.getMessage());
}

Files.isDirectory(Path path, LinkOption... options)： 判断路径是否为目录。

Path pathToTest = Paths.get("C:/myproject");
boolean isDirectory = Files.isDirectory(pathToTest);
System.out.println("是否为目录：" + isDirectory);

Files.isRegularFile(Path path, LinkOption... options)： 判断路径是否为常规文件。

Path pathToTest = Paths.get("C:/myproject/data.txt");
boolean isRegularFile = Files.isRegularFile(pathToTest);
System.out.println("是否为常规文件：" + isRegularFile);

Files.isHidden(Path path)： 判断文件是否为隐藏文件。

Path pathToTest = Paths.get("C:/myproject/hidden_file.txt"); // 假设这是一个隐藏文件
try {
    boolean isHidden = Files.isHidden(pathToTest);
    System.out.println("是否为隐藏文件：" + isHidden);
} catch (IOException e) {
    System.err.println("判断是否为隐藏文件失败：" + e.getMessage());
}

Files.isReadable(Path path)： 判断文件是否可读。

Path pathToTest = Paths.get("C:/myproject/data.txt");
boolean isReadable = Files.isReadable(pathToTest);
System.out.println("是否可读：" + isReadable);

Files.isWritable(Path path)： 判断文件是否可写。

Path pathToTest = Paths.get("C:/myproject/data.txt");
boolean isWritable = Files.isWritable(pathToTest);
System.out.println("是否可写：" + isWritable);

Files.isExecutable(Path path)： 判断文件是否可执行。

Path pathToTest = Paths.get("C:/myproject/executable.exe"); // 假设这是一个可执行文件
boolean isExecutable = Files.isExecutable(pathToTest);
System.out.println("是否可执行：" + isExecutable);

5. 目录的遍历：探险寻宝，目录任你游

Files.list(Path dir)： 返回目录下的所有文件和目录的 Path 对象流。

Path dirToBrowse = Paths.get("C:/myproject");
try (Stream<Path> stream = Files.list(dirToBrowse)) {
    stream.forEach(System.out::println);
} catch (IOException e) {
    System.err.println("遍历目录失败：" + e.getMessage());
}

Files.walk(Path start, int maxDepth, FileVisitOption... options)： 递归遍历目录下的所有文件和目录。

Path dirToBrowse = Paths.get("C:/myproject");
try (Stream<Path> stream = Files.walk(dirToBrowse, 2)) { // 遍历深度为 2
    stream.forEach(System.out::println);
} catch (IOException e) {
    System.err.println("遍历目录失败：" + e.getMessage());
}

Files.find(Path start, int maxDepth, BiPredicate<Path, BasicFileAttributes> matcher, FileVisitOption... options)： 根据条件查找文件和目录。

Path dirToBrowse = Paths.get("C:/myproject");
try (Stream<Path> stream = Files.find(dirToBrowse, 10,
        (path, attr) -> String.valueOf(path).endsWith(".txt"))) {
    stream.forEach(System.out::println);
} catch (IOException e) {
    System.err.println("查找文件失败：" + e.getMessage());
}

6. 文件系统的观察：风吹草动，尽在掌握

WatchService 接口可以让你监控文件系统的变化，例如文件的创建、删除、修改等。就像一个忠实的哨兵，时刻守护着你的文件系统。

Path dirToWatch = Paths.get("C:/myproject");
try {
    WatchService watchService = FileSystems.getDefault().newWatchService();
    dirToWatch.register(watchService,
            StandardWatchEventKinds.ENTRY_CREATE,
            StandardWatchEventKinds.ENTRY_DELETE,
            StandardWatchEventKinds.ENTRY_MODIFY);

    while (true) {
        WatchKey key = watchService.take();
        for (WatchEvent<?> event : key.pollEvents()) {
            WatchEvent.Kind<?> kind = event.kind();
            Path eventPath = (Path) event.context();

            System.out.println("Event: " + kind + " on " + eventPath);
        }
        boolean valid = key.reset();
        if (!valid) {
            break;
        }
    }
} catch (IOException | InterruptedException e) {
    System.err.println("文件系统观察失败：" + e.getMessage());
}

第三幕：高级魔法：ZIP 文件系统、自定义文件系统

NIO.2 不仅仅能操作普通的文件系统，还可以操作 ZIP 文件系统等。甚至可以自定义文件系统，实现更高级的文件管理功能。

1. ZIP 文件系统：压缩包里的乾坤，也能轻松掌控

Path zipFile = Paths.get("C:/myproject/archive.zip");
URI uri = URI.create("jar:" + zipFile.toUri());

try (FileSystem zipFileSystem = FileSystems.newFileSystem(uri, new HashMap<>())) {
    Path sourceFile = zipFileSystem.getPath("data.txt");
    Path targetFile = zipFileSystem.getPath("backup/data.txt");

    Files.copy(sourceFile, targetFile, StandardCopyOption.REPLACE_EXISTING);
    System.out.println("ZIP 文件系统操作成功！");
} catch (IOException e) {
    System.err.println("ZIP 文件系统操作失败：" + e.getMessage());
}

2. 自定义文件系统：打造专属文件系统，满足个性化需求

NIO.2 提供了 FileSystemProvider 抽象类，你可以继承它，实现自己的文件系统。这需要深入了解文件系统的底层原理，比较复杂，但也能实现高度定制化的文件管理功能。就像打造自己的专属武器，威力无穷！

总结：NIO.2，文件管理的未来之星

各位观众老爷们，今天的 “Java NIO.2 文件系统魔法秀” 就到这里了。希望通过今天的讲解，大家能够感受到 NIO.2 的强大和魅力，并将其应用到实际项目中，让文件管理变得更加轻松、高效。

NIO.2 不仅仅是一个 API，更是一种思想，一种面向未来的文件管理方式。掌握 NIO.2，你就能在文件管理领域游刃有余，成为真正的文件系统大师！ 🚀

记住，代码的世界充满乐趣，只要你敢于探索，勇于实践，就能发现更多的惊喜！感谢大家的观看，我们下期再见！ 👋

发表回复 取消回复

发表回复取消回复