Java 之所以能够霸占编程语言的榜首，其强大、丰富的类库功不可没，几乎所有的编程问题都能在其中找到解决方案。但在早期的版本当中，输入输出（I/O）流并不那么令开发者感到愉快：

1）JDK 1.4 之前的 I/O 没有缓冲区的概念、不支持正则表达式、支持的字符集编码有限等等； 2）JDK 1.4 的时候引入了非阻塞 I/O，也就是 NIO 1.0，但遍历目录很困难，不支持文件系统的非阻塞操作等等。

为了突破这些限制，JDK 1.7 的时候引入了新的 NIO，也就是本篇文章的主角——NIO 2.0。

01、基石：Path

Path 既可以表示一个目录，也可以表示一个文件，就像 File 那样——当然了，Path 就是用来取代 File 的。

1）可以通过 Paths.get() 创建一个 Path 对象，此时 Path 并没有真正在物理磁盘上创建；参数既可以是一个文件名，也可以是一个目录名；绝对路径或者相对路径均可。

2）可以通过 Files.notExists() 确认 Path（目录或者文件）是否已经存在。

3）可以通过 Files.createDirectory() 创建目录，此时目录已经在物理磁盘上创建成功，可通过资源管理器查看到。

4）可以通过 Files.createFile() 创建文件，此时文件已经在物理磁盘上创建成功，可通过资源管理器查看到。

5）可以通过 toAbsolutePath() 查看 Path 的绝对路径。

6）可以通过 resolve() 将 Path 连接起来，参数可以是一个新的 Path 对象，也可以是对应的字符串。

具体的代码如下：

public class Wanger {

	public static void main(String[] args) {
		// 相对路径
		Path dir = Paths.get("chenmo");

		// 输出 dir 的绝对路径
		System.out.println(dir.toAbsolutePath()); // 输出：D:\program\java.git\java_demo\chenmo

		if (Files.notExists(dir)) {
			try {
				// 如果目录不存在，则创建目录
				Files.createDirectory(dir);
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
		
		// 这时候 chenmo.txt 文件并未创建
		// 通过 resolve 方法把 dir 和 chenmo.txt 链接起来
		Path file = dir.resolve("chenmo.txt");

		// 输出 file 的绝对路径
		System.out.println(file.toAbsolutePath()); // 输出：D:\program\java.git\java_demo\chenmo\chenmo.txt

		if (Files.notExists(file)) {
			try {
				// 如果文件不存在，则创建文件
				Files.createFile(file);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

如果要将 File 转换为 Path，可以通过 File 类的 toPath() 方法完成。代码示例如下：

File file = new File("沉默王二.txt");
Path path = file.toPath();

如果要将 Path 转换为 File，可以通过 Path 类的 toFile() 方法完成。代码示例如下：

Path path = Paths.get("沉默王二.txt");
File file = path.toFile();

02、处理目录

NIO 2.0 新增的 java.nio.file.DirectoryStream<T> 接口可以非常方便地查找目录中的（符合某种规则的）文件，比如说我们要查找 chenmo 目录下的 txt 后缀的文件，代码示例如下：

// 相对路径
Path dir = Paths.get("chenmo");

try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, "*.txt")) {
	for (Path entry : stream) {
		System.out.println(entry.getFileName());
	}
} catch (IOException e) {
	e.printStackTrace();
}

1）Files.newDirectoryStream(Path dir, String glob) 会返回一个过滤后的 DirectoryStream（目录流，），第一个参数为目录，第二个参数为 glob 表达式，比如 *.txt 表示所有 txt 后缀的文件。

2）由于 DirectoryStream 继承了 Closeable 接口，所以它可以配合 try-with-resources 语法写出更安全的代码，目录流会自动调用 close 方法关闭流，释放与流相关的资源，不需要再通过 finally 进行主动关闭。

3）DirectoryStream 被称为目录流，允许方便地使用 for-each 结构来遍历目录。

03、处理目录树

目录树意味着一个目录里既有文件也有子目录，也可能都没有，也可能有其一。NIO 2.0 可以很方便地遍历一颗目录树，并操作符合条件的文件；这其中关键的一个方法就是 Files 类的 walkFileTree，其定义如下：

public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
        throws IOException
    {
        return walkFileTree(start,
                            EnumSet.noneOf(FileVisitOption.class),
                            Integer.MAX_VALUE,
                            visitor);
    }

第二个参数 FileVisitor 被称为文件访问器接口，它实现起来非常复杂，要实现 5 个方法呢，但幸好 JDK 的设计者提供了一个默认的实现类 SimpleFileVisitor，如果我们只想从目录树中找到 txt 后缀的文件，可以这样做：

// 相对路径
Path dir = Paths.get("chenmo");

try {
	Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
		@Override
		public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
			if (file.toString().endsWith(".txt")) {
				System.out.println(file.getFileName());
			}
			return FileVisitResult.CONTINUE;
		}
	});
} catch (IOException e) {
	e.printStackTrace();
}

通过创建匿名内部类来重写 SimpleFileVisitor 的 visitFile 方法，如果后缀名为 txt 就打印出来。

04、文件的删除、复制、移动

创建一个文件非常的简单，之前我们已经体验过了，那么删除一个文件也同样的简单，代码示例如下：

Files.delete(file);
Files.deleteIfExists(file);

使用 Files.delete() 删除文件之前最好使用 Files.exists() 判断文件是否存在，否则会抛出 NoSuchFileException；Files.deleteIfExists() 则不用。

复制文件也不复杂，代码示例如下：

Path source = Paths.get("沉默王二.txt");
Path target = Paths.get("沉默王二1.txt");
Files.copy(source, target);

移动文件和复制文件非常相似，代码示例如下：

Path source = Paths.get("沉默王二.txt");
Path target = Paths.get("沉默王二1.txt");
Files.move(source, target);

05、快速地读写文件

NIO 2.0 提供了带有缓冲区的读写辅助方法，使用起来也非常的简单。可以通过 Files.newBufferedWriter() 获取一个文件缓冲输入流，并通过 write() 方法写入数据；然后通过 Files.newBufferedReader() 获取一个文件缓冲输出流，通过 readLine() 方法读出数据。代码示例如下。

Path file = Paths.get("沉默王二.txt");

try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
	writer.write("一个有趣的程序员");
} catch (Exception e) {
	e.printStackTrace();
}

try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {

	String line;
	while ((line = reader.readLine()) != null) {
		System.out.println(line);
	}
} catch (Exception e) {
	e.printStackTrace();
}

06、重要：异步 I/O 操作

实话实说吧，上面提到的那些都算是 NIO 2.0 的甜点，而异步 I/O 操作（也称 AIO）才算是真正重要的内容。异步 I/O 操作可以充分利用多核 CPU 的特点，不需要再像以前那样启动一个线程来对 I/O 进行处理，免得阻塞了主线程的其他操作。

异步 I/O 操作的核心概念是发起非阻塞方式的 I/O 操作，当 I/O 操作完成时通知。可以分为两种形式：Future 和 Callback。如果我们希望主线程发起 I/O 操作并轮循等待结果时，一般使用 Future 的形式；而 Callback 的基本思想是主线程派出一个侦查员（CompletionHandler）到独立的线程中执行 I/O 操作，操作完成后，会触发侦查员的 completed 或者 failed 方法。

1）Future

先来看一个示例，代码如下：

public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
	Path file = Paths.get("沉默王二.txt");
	AsynchronousFileChannel channel = AsynchronousFileChannel.open(file);
	Future<Integer> result = channel.read(ByteBuffer.allocate(100_000), 0);
	while (!result.isDone()) {
		System.out.println("主线程继续做事情");
	}

	Integer bytesRead = result.get();
	System.out.println(bytesRead);
}

1）通过 AsynchronousFileChannel.open() 打开一个异步文件通道 channel。

2）用 Future 来保存从通道中读取的结果。

3）通过 isDone() 轮循判断异步 I/O 操作是否完成，如果没有完成的话，主线程可以继续做自己的事情。

2）Callback

先来看一个示例，代码如下：

public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
	Path file = Paths.get("沉默王二.txt");
	AsynchronousFileChannel channel = AsynchronousFileChannel.open(file);
	channel.read(ByteBuffer.allocate(100_000), 0, null, new CompletionHandler<Integer, ByteBuffer>() {
		public void completed(Integer result, ByteBuffer attachment) {
			System.out.println(result);
		}
		
		public void failed(Throwable exc, ByteBuffer attachment) {
			System.out.println(exc.getMessage());
		}
	});
	
	System.out.println("主线程继续做事情");

}

1）通过 AsynchronousFileChannel.open() 打开一个异步文件通道 channel。

2）在 read 方法中使用匿名内部类的形式启用 CompletionHandler，然后实现 CompletionHandler 的两个监听方法，completed 的时候打印结果，failed 的时候打印异常信息。

不管是 Future 形式还是 Callback 形式，总之异步 I/O 是一个强大的特性，可以保证在处理大文件时性能不受到显著的影响。

07、最后

欢迎关注「沉默王二」公众号，后台回复关键字「java」即可免费获取「Java 程序员进阶必读资料」。