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

时间：2022-10-09 14:31:59

本文部分摘自 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")));

相关文章