学习使用Path、Paths和Files类来操作文件系统
在Java 7引入的NIO.2（New Input/Output 2）中，Path、Paths和Files类是处理文件系统操作的核心类。它们提供了一套强大的文件I/O操作接口，使得读写文件、访问文件属性、遍历文件目录等操作变得更加简洁和直观。
Path和Paths
Path接口代表文件系统中的路径。它不仅可以用来表示文件，也可以表示目录。Path对象包含了文件系统的层级结构，并提供了许多用于路径操作的方法，如解析、比较、绝对路径获取等。
Paths是一个工具类，提供了静态方法来更容易地获取Path对象。
创建Path对象
使用Paths.get(String first, String... more)方法可以创建Path对象：
java
Path path = Paths.get("/home/user/docs/myfile.txt");
Path anotherPath = Paths.get("home", "user", "docs", "myfile.txt");Files类
Files类提供了静态方法来操作文件和目录，如创建、删除、复制、移动文件/目录，读取文件内容，写入文件内容，以及访问文件的属性等。
文件操作
- 读取文件内容：
java
Path path = Paths.get("data.txt");
List<String> lines = Files.readAllLines(path);写入文件内容：
java
Path path = Paths.get("output.txt");
List<String> lines = Arrays.asList("Line 1", "Line 2");
Files.write(path, lines, StandardCharsets.UTF_8);文件和目录的创建与删除
- 创建文件：
java
Path newPath = Files.createFile(Paths.get("newFile.txt"));创建目录：
java
Path newDir = Files.createDirectories(Paths.get("newDir/subDir"));删除文件/目录：
java
Files.delete(Paths.get("toBeDeleted.txt"));文件复制和移动
- 复制文件：
java
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);移动文件：
java
Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);访问文件属性
Files类提供了方法来检查和修改文件的属性，比如大小、最后修改时间、权限等。
java
Path path = Paths.get("example.txt");
long size = Files.size(path);
FileTime fileTime = Files.getLastModifiedTime(path);遍历目录
使用Files.walk(Path start, int maxDepth, FileVisitOption... options)方法可以遍历目录：
java
try (Stream<Path> stream = Files.walk(Paths.get("startDir"), 3)) {
stream.forEach(System.out::println);
}总结
Path、Paths和Files类极大地简化了文件系统的操作，提供了一种更现代、更直观的API来处理文件和目录。通过这些类，开发者可以轻松执行文件读写、属性访问、目录遍历等操作，而不必处理传统java.io包中繁琐的文件处理方式。熟练使用这些NIO.2中的类对于进行高效、可靠的文件操作至关重要。
AsynchronousFileChannel实现异步文件I/O操作
AsynchronousFileChannel是Java NIO.2中引入的一个功能强大的类，它支持对文件的异步读写操作。这意味着程序可以启动一个读写文件的操作，在等待操作完成的同时，还能继续执行其他任务。当文件I/O操作实际完成时，程序将通过回调或Future对象获得通知。这种机制特别适合于处理大文件或执行密集的I/O操作，能显著提高应用程序的响应性和性能。
使用AsynchronousFileChannel
打开AsynchronousFileChannel
要使用AsynchronousFileChannel，首先需要打开一个文件通道。可以通过调用open()方法实现，这个方法需要一个Path对象和一组OpenOption参数来指定如何打开文件。
java
Path path = Paths.get("example.txt");
AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE);异步读取文件
异步读取文件可以通过read()方法实现，这个方法接受一个ByteBuffer作为容器来存储读取的数据，一个文件位置指示从哪里开始读取，以及一个附件对象和一个CompletionHandler作为回调来处理操作完成或失败的情况。
java
ByteBuffer buffer = ByteBuffer.allocate(1024);
long position = 0;
fileChannel.read(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("Read done, result = " + result);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
System.err.println("Read failed");
exc.printStackTrace();
}
});异步写入文件
异步写入文件与读取类似，使用write()方法。这个方法同样需要一个ByteBuffer来提供写入的数据，一个文件位置，以及一个附件对象和一个CompletionHandler。
java
String input = "Hello, Asynchronous World!";
ByteBuffer buffer = ByteBuffer.wrap(input.getBytes());
long position = 0;
fileChannel.write(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("Write done, result = " + result);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
System.err.println("Write failed");
exc.printStackTrace();
}
});使用Future处理结果
除了使用CompletionHandler，AsynchronousFileChannel的读写操作也可以返回一个Future对象，你可以用它来查询操作的状态或等待操作完成。
java
ByteBuffer buffer = ByteBuffer.allocate(1024);
Future<Integer> future = fileChannel.read(buffer, 0);
// 使用Future等待异步操作完成
Integer result = future.get();
System.out.println("Read done, result = " + result);总结
AsynchronousFileChannel提供了一种高效的机制来执行非阻塞的文件I/O操作，使得应用程序在进行大量I/O操作时仍能保持高响应性。通过异步操作的回调机制（CompletionHandler）或Future对象，开发者可以灵活地控制程序的流程，优化应用性能。掌握AsynchronousFileChannel对于开发高性能的Java应用至关重要。
练习使用选择器（Selectors）和套接字通道（Socket Channels）进行网络编程
使用选择器（Selectors）和套接字通道（Socket Channels）是Java NIO中处理网络操作的核心机制。它们允许单个线程同时管理多个网络连接，这是通过非阻塞I/O（NIO）实现的。这种模型相比于传统的每个连接使用一个线程的方式（如Java IO中的ServerSocket和Socket），可以大幅度提高网络应用的可伸缩性和性能。
步骤1: 创建选择器
选择器是Java NIO中的一个组件，用于检测一个或多个NIO通道（Channel）的状态变化（例如，连接打开、数据到达）。首先，你需要创建一个选择器实例：
java
Selector selector = Selector.open();步骤2: 创建套接字通道
接下来，创建一个非阻塞的套接字通道（Socket Channel）。对于服务器端，你需要创建一个ServerSocketChannel并绑定到特定端口。对于客户端，创建一个SocketChannel并连接到服务器。
服务器端：
java
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); // 配置为非阻塞模式
serverChannel.bind(new InetSocketAddress("localhost", 8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);客户端：
java
SocketChannel clientChannel = SocketChannel.open();
clientChannel.configureBlocking(false);
clientChannel.connect(new InetSocketAddress("localhost", 8080));
clientChannel.register(selector, SelectionKey.OP_CONNECT);步骤3: 选择器循环
一旦选择器和通道设置完毕，你就可以使用选择器循环来等待事件的发生（如新连接的接受、数据的读取或写入）。
java
while(true) {
selector.select(); // 阻塞，直到至少有一个注册的事件发生
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(key.isAcceptable()) {
// 处理接受新连接
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
SocketChannel client = serverChannel.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
System.out.println("Accepted new connection from client: " + client);
} else if(key.isReadable()) {
// 处理读
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int numRead = client.read(buffer);
if(numRead > 0) {
// 处理数据
System.out.println("Read data: " + new String(buffer.array()));
} else if(numRead == -1) {
// 连接已经关闭
client.close();
}
}
// 移除已选的键，因为已经处理过了
keyIterator.remove();
}
}步骤4: 数据读取和写入
在选择器循环中，当你检测到OP_READ事件时，可以从通道中读取数据。同样，当你要写入数据到通道时，可以注册OP_WRITE事件，但在写入数据前通常不需要注册写事件，只有在写缓冲区满时才注册OP_WRITE事件，完成写操作后取消注册。
java
// 写数据示例
String message = "Hello from server!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
clientChannel.write(buffer);总结
通过上述步骤，你可以使用选择器和套接字通道在Java中实现高效的网络编程。这种方法相比于传统的阻塞IO模型，可以处理成千上万的并发连接，是构建高性能网络应用的关键技术之一。实践这些概念将帮助你更好地理解非阻塞IO的工作机制，并在实际项目中运用它们。