Java7 新特性 —— java.nio.file 文件操作

本文部分摘自 On Java 8

自 Java7 开始，Java 终于简化了文件读写的基本操作，新增了 java.nio.file 库，通过与 Java8 新增的 stream 结合可以使得文件操作变得更加优雅

文件和目录路径

java.nio.file.Paths 类包含一个重载方法 static.get()，可以接受一系列 String 字符串或一个统一资源标识符 URI 作为参数，并且转换返回一个 Paths 对象。使用 Paths 对象可以很轻松地生成路径的某一部分：

Path path1 = Paths.get("C:", "path", "to", "nowhere", "NoFile.txt");
Path path2 = Paths.get("C:/path/to/nowhere/NoFile.txt");
URI uri = path2.toUri();
Path3 path3 = Paths.get(uri);

一个 Path 对象表示一个文件或者目录的路径，是一个跨操作系统和文件系统的抽象，目的是在构造路径时可以不必关注底层操作系统。如果 Path 仅由一个空的名称元素组成，则认为是空的路径。使用空路径访问文件等同于访问文件系统的默认目录。Path 接口的实现是不可变且安全的，可供多个并行线程使用

使用 Path 对象可以非常容易地生成路径的某一部分：

// 返回表示此路径的绝对路径的Path对象
Path p = Paths.get("PartsOfPaths.java").toAbsolutePath();
// 返回表示此路径的真实路径的Path对象，也即是带上盘符（根路径）
Path p2 = Paths.get("PartsOfPaths.java").toRealPath();
// getNameCount() 返回路径中的名称元素的数量
// 例如 p 的绝对路径是 C:\User\Bruce\Documents\GitHub\PartsOfPaths.java
// 则此循环会依次输出 User、Bruce、Documents、PartsOfPaths.java
for(int i = 0; i < p.getNameCount(); i++) {
    // 返回此路径的名称元素作为 Path对象
    System.out.println(p.getName(i));
}
// 测试路径是否以给定的路径结束，这里会输出 end with '.java':false
System.out.println("ends with '.java': " + p.endsWith(".java"));
// Path 也实现了 iterable 接口，会对路径中的名称元素进行遍历
for(Path pp : p) {
	...
}
// getRoot() 返回此路径的根路径作为Path对象，为null则该路径不具有根
// startsWith() 效果和 endsWith() 相似
// 这里会输出 Starts with C:\ true
System.out.println("Starts with " + p.getRoot() + " " + p.startsWith(p.getRoot()));

有时我们还需要通过对 Path 对象增加或修改一部分来构造一个新的 path 对象，可以使用 relativize() 移除 Path 的根路径，或者使用 resolve() 添加 Path 的尾路径，注意添加的路径可以不是真实存在的

// 使用..可以跳转到上一级路径，但必须使用normalize()方法
// 假设当前路径为C:\Users\Bruce\Documents\GitHub\PartsOfPaths.java，则输出C:\Users
Path base = Paths.get("..", "..", "..").toAbsolutePath().normalize();
// 返回表示此路径的绝对路径的Path对象
Path p = Paths.get("PartsOfPaths.java").toAbsolutePath();
// 构造此路径和给定路径之间的相对路径
Path p2 = base.relativize(p);
// 使用resolve构造路径
// 此时路径为C:\Users\Bruce\Documents\GitHub\string
Path convoluted = p.getParent().resolve("string");

有关 Path 的更多用法，可以查阅 Java API 了解更多信息

Files

Files 工具类包含一系列完整的方法用于获取 Path 的相关信息

Path p = Paths.get("PartsOfPaths.java").toAbsolutePath();
// 文件是否存在
Files.exists(p);
// 文件是否是目录
Files.isDirectory(p);
// 文件是否可执行
Files.isExecutable(p);
// 文件是否可读
Files.isReadable(p);
// 文件是否是具有不透明内容的常规文件
// 比如在linux下，设备也是一个文件，这个就不属于Regular File
Files.isRegularFile(p);
// 文件是否可写
Files.isWritable(p);
// 文件是否不存在
Files.notExists(p);
// 文件是否被隐藏
Files.isHidden(p);
// 返回文件的大小（以字节为单位）
Files.size(p);
// 返回与文件存储相关的信息
Files.getFileStore(p);
// 返回文件的上次修改时间
Files.getLastModifiedTime(p);
// 返回文件的所有者
Files.getOwner(p);
// 探测文件的内容类型
Files.probeContentType(p);
// 文件是否是符号链接
Files.isSymbolicLink(p);

虽然 Files 工具类包含大部分我们需要的目录和文件操作方法，但并没有包含删除目录树的相关方法，因此我们必须自己实现

public class RmDir {

    public static void rmdir(Path dir) throws IOException {

        Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                Files.delete(file);
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                Files.delete(dir);
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

删除目录树意味着要遍历每个子目录和文件，FileVisitor 提供了一种标准机制来访问集合中的每个对象，然后你需要提供在每个对象上执行的方法，此操作的定义取决于实现 FileVisitor 的四个抽象方法

preVisitDirectory();	// 在访问目录中条目之前在目录上运行
visitFile();	// 运行目录中的每一个文件
visitFileFailed()	// 调用无法访问的文件
postVisitDirectory();	// 在访问目录中条目之后在目录上运行，包括所有的子目录

java.nio.file.SimpleFileVisitor 提供了所有方法的默认实现，因此在匿名内部类中，我们只需要重写 visitFile() 和 postVisitDirectory() 实现删除文件和删除目录，两者都应该返回标志位决定是否继续访问，我们可以根据需要有条件地进行删除

文件系统

我们需要一种方法查找文件系统的相关信息，可以通过使用静态的 FileSystems 工具类获取默认的文件系统，也可以在 path 对象上调用 getFileSystem() 以获取创建该 Path 的文件系统

// 返回默认的文件系统
FileSystem fsys = FileSystems.getDefault();
// 返回一个迭代器，遍历底层文件存储
for(FileStore fs : fsys.getFileStores()) {
    show("File Store", fs);
}
// 返回一个迭代器，来遍历根目录的路径
for(Path rd : fsys.getRootDirectories()) {
    show("Root Directory", rd);
}
// 返回名称分隔符
String sep = fsys.getSeparator();
// 返回此文件系统的可选操作
UserPrincipalLookupService lookupService = fsys.getUserPrincipalLookupService();
// 文件系统是否打开，默认始终打开
fsys.isOpen();
// 文件系统是否只允许只读访问其文件存储
fsys.isReadOnly();
// 返回创建此文件系统的提供程序
FileSystemProvider provider = fsys.provider();
// 返回文件系统支持的文件属性视图名称
Set<String> set = fsys.supportedFileAttributeViews();

路径监听

通过 WatchService 可以设置一个进程对目录中的更改做出响应，一个 WatchService 对象可以通过 FileSystem 生成

在下面这个例子中，delTxtFiles() 作为一个单独的任务执行，该任务将遍历整个目录并删除以 .txt 结尾的所有文件，WatchService 会对文件的删除做出反应：

Path test = Paths.get("test");
// 要监视的文件
Files.createFile(test.resolve("Hello.txt"));
// 生成WatchService对象
WatchService watcher = FileSystems.getDefault().newWatchService();
// 注册到test路径，并指定监听的动作
test.register(watcher, ENTRY_DELETE);
// 使用线程池执行删除.txt结尾的文件
// 可以简单理解PathWatcher::delTxtFiles就是我们自定义的方法
// 作用就是遍历test及其子目录删除所有.txt结尾的文件
Executors.newSingleThreadScheduledExecutor().schedule(PathWatcher::delTxtFiles,
        250, TimeUnit.MILLISECONDS);
// watcher.take()将等待并阻塞在这里，直到目标事件发生
WatchKey key = watcher.take();
// 展示能对WatchEvent执行的全部操作
for(WatchEvent evt : key.pollEvents()) {
    System.out.println("evt.context(): " + evt.context() +
                       "\nevt.count(): " + evt.count() +
                       "\nevt.kind(): " + evt.kind());
    System.exit(0);
}

需要注意的是，WatchService 只会监视给定的目录，并不包含其下的所有子目录，所有本例中如果 test 下的子目录还有其他 .txt 结尾的文件，并不会触发 WatchService。要想监视整个子目录，必须在每个子目录放置一个 WatchService

文件查找与读写

我们可以通过在 FileSystem 对象上调用 getPathMatcher() 获得一个 PathMatcher，然后传入你感兴趣的模式。模式有两个选项：glob 和 regex，glob 比较简单，功能也很强大，这里主要介绍 glob

Path test = Paths.get("test");
// 查找当前目录及其子目录下所有以.tmp或.txt结尾的Path
// **/表示当前目录及其所有子目录
// * 表示任何字符，大括号表示一系列的可能性
PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**/*.{tmp,txt}");
Files.walk(test).filter(matcher::matches).forEach(System.out::println);

找到文件之后，我们就可以对路径和目录做任何事情。如果一个文件很小，那么 java.nio.file.Files 类中的方法可以帮助你轻松地读写文本和二进制文件

使用 Files.readAllLines() 方法可以一次读取整个文件，产出一个 List<String>，在这里结合流的知识，对文件内容进行打印

Files.readAllLines(Paths.get("../streams/Cheese.dat")).stream()
    .filter(line -> !line.startWith("//"))
    .map(line -> line.substring(0, line.lengtg(/2)))
    .forEach(System.out::println);

如果一个文件太大，一次性读完会耗尽内存，或者说你只需要在文件的读取中途操作以获得想要的结果，可以使用 Files.lines() 将文件转换为行的 stream

// 跳过十三行，然后选择下一行并将其打印出来
Files.lines(Paths.get("PathInfo.java")).skip(13).findFirst().ifPresent(System.out::println);

使用 Files.write() 写入 byte 数组或任何 iterable 对象

// 写入 byte 数组
byte[] bytes = new byte[SIZE];
new Random(47).nextBytes(bytes);
Files.write(Paths.get("bytes.dat"), bytes);
System.out.println("bytes.dat: " + Files.size(Paths.get("bytes.dat")));
// 写入 iterable 对象
List<String> lines = Files.readAllLines(Paths.get("../streams/Cheese.dat"));
Files.write(Paths.get("Cheese.txt"), lines);
System.out.println("Cheese.txt: " + Files.size(Paths.get("Cheese.txt")));