手册   游戏   WEB   字典   单词   在线工具  

Java NIO 学习系列七: Path,Files,AsynchronousFileChannel

相对于标准 Java IO 中通过 File 来指向文件和目录, Java NIO 中提供了更丰富的类来支持对文件和目录的操作, 不仅仅支持更多操作, 还支持诸如异步读写等特性, 本文我们就来学习一些 Java NIO 提供的和文件相关的类:

  1. Java NIO Path
  2. Java NIO Files
  3. Java NIO AsynchronousFileChannel

总结

1. Java NIO Path

Java Path 是一个接口, 位于 java.nio.file 包中, Java 7 中引入到 Java NIO 中.

一个 Java Path 实现的实例对象代表文件系统中的一个路径, 指向文件和目录,(标准 Java IO 中是通过 File 来指向文件和路径的), 以绝对路径或者相对路径的方式.

java.nio.file.Path 接口很多方面类似于 java.io.File 类, 但是两者之间也是有细微的差别的. 在大多数场景下是可以用 Path 来代替 File 的.

1.1 创建 Path 实例对象

可以通过 Paths 类的静态工厂方法 get()来创建一个 Path 实例对象:

  1. import java.nio.file.Path;
  2. import java.nio.file.Paths;
  3. public class PathExample {
  4.     public static void main(String[] args) {
  5.         Path path = Paths.get("c:\\data\\myfile.txt");
  6.     }
  7. }
  8. 1.2 Creating an Absolute Path

通过直接指定绝对路径可以创建使用绝对路径方式指向文件的 Path:

  1. // Windows 系统
  2. Path path = Paths.get("c:\\data\\myfile.txt");
  3. // Linux 系统
  4. Path path = Paths.get("/home/jakobjenkov/myfile.txt");
  5. 1.3 Creating a Relative Path

通过如下方式可以创建使用相对路径方式指向文件的 Path:

  1. Path projects = Paths.get("d:\\data", "projects");
  2. Path file = Paths.get("d:\\data", "projects\\a-project\\myfile.txt");

采用相对路径的方式时, 有两个符号可以用来表示路径:

.

..

"." 可以表示当前目录, 如下例子是打印当前目录(即应用程序的根目录):

  1. Path currentDir = Paths.get(".");
  2. System.out.println(currentDir.toAbsolutePath());

".." 表示父文件夹.

当路径中包含如上两种符号时, 可以通过调用 normalize()方法来将路径规范化:

  1. String originalPath = "d:\\data\\projects\\a-project\\..\\another-project";
  2. Path path1 = Paths.get(originalPath);
  3. System.out.println("path1 =" + path1);
  4. Path path2 = path1.normalize();
  5. System.out.println("path2 =" + path2);

输出结果如下:

  1. path1 = d:\data\projects\a-project\..\another-project
  2. path2 = d:\data\projects\another-project
  3. 2. Java NIO Files

Java NIO Files 类 (java.nio.file.Files) 提供了一些方法用来操作文件, 其是和上面提到的 Path 一起配合使用的.

2.1 Files.exists()

该方法可以用来检查 Path 指向的文件是否真实存在, 直接看例子:

  1. Path path = Paths.get("data/logging.properties");
  2. boolean pathExists = Files.exists(path, new LinkOption[]{
  3. 	LinkOption.NOFOLLOW_LINKS	
  4. });
  5. 2.2 Files.createDirectory()

该方法会在硬盘上创建一个新的目录(即文件夹):

  1. Path path = Paths.get("data/subdir");
  2. try {
  3.     Path newDir = Files.createDirectory(path);
  4. } catch(FileAlreadyExistsException e){
  5.     // the directory already exists.
  6. } catch (IOException e) {
  7.     //something else went wrong
  8.     e.printStackTrace();
  9. }
  10. 2.3 Files.copy()

该方法会将文件从一个地方复制到另一个地方:

  1. Path sourcePath = Paths.get("data/logging.properties");
  2. Path destinationPath = Paths.get("data/logging-copy.properties");
  3. try {
  4.     Files.copy(sourcePath, destinationPath);
  5. } catch(FileAlreadyExistsException e) {
  6.     //destination file already exists
  7. } catch (IOException e) {
  8.     //something else went wrong
  9.     e.printStackTrace();
  10. }

如果目标文件已存在, 这里会抛出 java.nio.file.FileAlreadyExistsException 异常, 想要强制覆盖文件也是可以的:

  1. Path sourcePath = Paths.get("data/logging.properties");
  2. Path destinationPath = Paths.get("data/logging-copy.properties");
  3. try {
  4.     Files.copy(sourcePath, destinationPath,
  5.             StandardCopyOption.REPLACE_EXISTING);
  6. } catch(FileAlreadyExistsException e) {
  7.     //destination file already exists
  8. } catch (IOException e) {
  9.     //something else went wrong
  10.     e.printStackTrace();
  11. }
  12. 2.4 Files.move()

该方法能够移动文件, 也可以实现重命名的效果:

  1. Path sourcePath = Paths.get("data/logging-copy.properties");
  2. Path destinationPath = Paths.get("data/subdir/logging-moved.properties");
  3. try {
  4.     Files.move(sourcePath, destinationPath,
  5.             StandardCopyOption.REPLACE_EXISTING);
  6. } catch (IOException e) {
  7.     //moving file failed.
  8.     e.printStackTrace();
  9. }
  10. 2.5 Files.delete()

该方法能够删除 Path 实例指向的文件或目录:

  1. Path path = Paths.get("data/subdir/logging-moved.properties");
  2. try {
  3.     Files.delete(path);
  4. } catch (IOException e) {
  5.     //deleting file failed
  6.     e.printStackTrace();
  7. }
  8. Path path = Paths.get("data/subdir/logging-moved.properties");
  9. try {
  10.     Files.delete(path);
  11. } catch (IOException e) {
  12.     //deleting file failed
  13.     e.printStackTrace();
  14. }

该方法删除目录时只能删除空目录, 如果想删除下面有文件的目录则需要进行递归删除, 后面会介绍.

2.6 Files.walkFileTree()

该方法能够递归地获取目录树, 该方法接收两个参数, 一个是指向目标目录, 另一个是一个 FileVisitor 类型对象:

  1. Files.walkFileTree(path, new FileVisitor<Path>() {
  2.   @Override
  3.   public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
  4.     System.out.println("pre visit dir:" + dir);
  5.     return FileVisitResult.CONTINUE;
  6.   }
  7.   @Override
  8.   public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  9.     System.out.println("visit file:" + file);
  10.     return FileVisitResult.CONTINUE;
  11.   }
  12.   @Override
  13.   public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
  14.     System.out.println("visit file failed:" + file);
  15.     return FileVisitResult.CONTINUE;
  16.   }
  17.   @Override
  18.   public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
  19.     System.out.println("post visit directory:" + dir);
  20.     return FileVisitResult.CONTINUE;
  21.   }
  22. });

FileVisitor 是一个接口, 你需要实现它, 接口的定义如下:

  1. public interface FileVisitor {
  2.     public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException;
  3.     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException;
  4.     public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException;
  5.     public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
  6. }

该接口中包含 4 个方法, 分别在目录转换的四个不同阶段调用:

preVisitDirectory()方法在访问目录之前调用, 而 postVisitorDirectory()方法是在访问目录之后调用;

visitFile()方法会在访问每个文件 (访问目录是不会调用的) 时调用一次, 而 visitorFileFailed()会在访问文件失败时被调用, 比如没有访问权限或者别的问题.

这四个方法都会返回一个 FileVisitResult 枚举对象, 包含如下成员:

  1. CONTINUE
  2. TERMINATE
  3. SKIP_SIBLINGS
  4. SKIP_SUBTREE

被调用的如上四个方法通过这些返回值来判断是否要继续遍历目录.

CONTINUE, 意味着继续;

TERMINATE, 意味着终止;

SKIP_SIBLINGS, 意味着继续, 但是不再访问该文件或目录的兄弟;

SKIP_SUBTREE, 意味着继续, 但是不再访问该目录下的条目. 只有 preVisitDirectory()返回该值才有意义, 其余三个方法返回则会当做 CONTINUE 处理;

如果不想自己实现该接口, 也可以使用 SimpleFileVisitor, 这是一个默认实现, 如下是一个利用 SimpleFileVisitor 来实现文件查找, 删除的例子:

递归查找文件

  1. Path rootPath = Paths.get("data");
  2. String fileToFind = File.separator + "README.txt";
  3. try {
  4.   Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
  5.     @Override
  6.     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  7.       String fileString = file.toAbsolutePath().toString();
  8.       if(fileString.endsWith(fileToFind)){
  9.         System.out.println("file found at path:" + file.toAbsolutePath());
  10.         return FileVisitResult.TERMINATE;
  11.       }
  12.       return FileVisitResult.CONTINUE;
  13.     }
  14.   });
  15. } catch(IOException e){
  16.     e.printStackTrace();
  17. }

递归删除目录

因为 delete()方法只能删除空目录, 对于非空目录则需要将其进行遍历以逐个删除其子目录或文件, 可以通过 walkFileTree()来实现, 在 visitFile()方法中删除子目录, 而在 postVisitDirectory()方法中删除该目录本身:

  1. Path rootPath = Paths.get("data/to-delete");
  2. try {
  3.   Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
  4.     @Override
  5.     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  6.       System.out.println("delete file:" + file.toString());
  7.       Files.delete(file);
  8.       return FileVisitResult.CONTINUE;
  9.     }
  10.     @Override
  11.     public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
  12.       Files.delete(dir);
  13.       System.out.println("delete dir:" + dir.toString());
  14.       return FileVisitResult.CONTINUE;
  15.     }
  16.   });
  17. } catch(IOException e){
  18.   e.printStackTrace();
  19. }

其实利用 walkFileTree()方法, 我们可以很轻松地指定自己的逻辑, 而无需考虑是如何遍历的, 如果要用标准 Java IO 提供的 File 来实现类似功能我们还需要自己处理整个遍历的过程.

2.7 其它有用方法

java.nio.file.Files 类还包含了很多别的有用方法, 比如创建符号链接, 文件大小, 设置文件权限, 这里就不一一介绍了, 有兴趣的可以参考 Java 官方文档.

3. Java NIO AsynchronousFileChannel

Java 7 中引入了 AsynchronousFileChannel, 使得可以异步地读写数据到文件.

3.1 Creating an AsynchronousFileChannel

通过其静态方法可以创建一个 AsynchronousFileChannel.

  1. Path path = Paths.get("data/test.xml");
  2. AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);

第一个参数是一个指向要和 AsynchronousFileChannel 关联的文件的 Path 实例. 第二个参数代表要对文件指向的操作, 这里我们指定 StandardOpenOption.READ, 意思是执行读操作.

3.2 Reading Data

从 AsynchronousFileChannel 读数据有两种方式:

通过 Future 读数据

第一种方式是调用一个返回 Future 的 read()方法:

Future<Integer> operation = fileChannel.read(buffer, 0);

这个版本的 read()方法, 其第一个参数是一个 ByteBuffer, 数据从 channel 中读到 buffer 中; 第二个参数是要从文件中开始读取的字节位置.

该方法会马上返回, 即使读操作实际上还没有完成. 通过调用 Future 的 isDone()方法可以知道读操作是否完成了.

如下是一个更详细的例子:

  1. AsynchronousFileChannel fileChannel =  AsynchronousFileChannel.open(path, StandardOpenOption.READ);
  2. ByteBuffer buffer = ByteBuffer.allocate(1024);
  3. long position = 0;
  4. Future<Integer> operation = fileChannel.read(buffer, position);
  5. while(!operation.isDone());
  6. buffer.flip();
  7. byte[] data = new byte[buffer.limit()];
  8. buffer.get(data);
  9. System.out.println(new String(data));
  10. buffer.clear();

在这个例子中, 当调用了 AsynchronousFileChannel 的 read()方法之后, 进入循环直到 Future 对象的 isDone()返回 true. 当然这种方式并没有有效利用 CPU, 只是因为本例中需要等到读操作完成, 其实这个等待过程我们可以让线程做别的事情.

通过 CompletionHandler 读数据

第二种读数据的方式是调用其包含 CompletionHandler 参数的 read()方法:

  1. fileChannel.read(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() {
  2.     @Override
  3.     public void completed(Integer result, ByteBuffer attachment) {
  4.         System.out.println("result =" + result);
  5.         attachment.flip();
  6.         byte[] data = new byte[attachment.limit()];
  7.         attachment.get(data);
  8.         System.out.println(new String(data));
  9.         attachment.clear();
  10.     }
  11.     @Override
  12.     public void failed(Throwable exc, ByteBuffer attachment) {
  13.     }
  14. });

当读操作完成之后会调用 ComplementHandler 的 completed()方法, 该方法的第一个入参是一个整型变量, 代表读了多少字节数据, 第二个入参是一个 ByteBuffer, 保存着已经读取的数据.

如果读失败了, 则会调用 ComplementHandler 的 fail()方法.

3.3 Writing Data

与读类似, 写数据也支持两种方式.

通过 Future 写

如下是一个写数据的完整例子:

  1. Path path = Paths.get("data/test-write.txt");
  2. AsynchronousFileChannel fileChannel =  AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
  3. ByteBuffer buffer = ByteBuffer.allocate(1024);
  4. long position = 0;
  5. buffer.put("test data".getBytes());
  6. buffer.flip();
  7. Future<Integer> operation = fileChannel.write(buffer, position);
  8. buffer.clear();
  9. while(!operation.isDone());
  10. System.out.println("Write done");

过程比较简单, 就不讲一遍了. 这个例子中有一个问题需要注意, 文件必须事先准备好, 如果不存在文件则会抛出 java.nio.file.NoSuchFileException 异常.

可以通过如下方式判断文件是否存在:

  1. if(!Files.exists(path)){
  2.     Files.createFile(path);
  3. }

通过 CompletionHandler 写数据

可以借助 CompletionHandler 来通知写操作已经完成, 示例如下:

  1. Path path = Paths.get("data/test-write.txt");
  2. if(!Files.exists(path)){
  3.     Files.createFile(path);
  4. }
  5. AsynchronousFileChannel fileChannel =
  6.     AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
  7. ByteBuffer buffer = ByteBuffer.allocate(1024);
  8. long position = 0;
  9. buffer.put("test data".getBytes());
  10. buffer.flip();
  11. fileChannel.write(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() {
  12.     @Override
  13.     public void completed(Integer result, ByteBuffer attachment) {
  14.         System.out.println("bytes written:" + result);
  15.     }
  16.     @Override
  17.     public void failed(Throwable exc, ByteBuffer attachment) {
  18.         System.out.println("Write failed");
  19.         exc.printStackTrace();
  20.     }
  21. });
  22. System.out.println("异步执行哦");

如上是一个异步写入数据的例子, 为了演示效果, 我特意在 调用 write 方法之后打印了一行日志, 运行结果如下:

异步执行哦

bytes written: 9

说明调用 write 方法并没有阻塞, 而是继续往下执行, 所以先打印日志, 然后数据写好之后回调 completed()方法.

4. 总结

本文总结了 Java NIO 中提供的对文件操作的相关类: Path,Files,AsynchronousFileChannel.

Path 是一个接口, 其实现实例可以指代一个文件或目录, 作用与 Java IO 中的 File 类似. Path 接口很多方面类似于 java.io.File 类, 但是两者之间也是有细微的差别的, 不过在大多数场景下是可以用 Path 来代替 File 的.

Files 是一个类, 提供了很多方法用来操作文件, 是和上面提到的 Path 一起配合使用的, Files 提供的对文件的操作功能要多于 File.

AsynchronousFileChannel 是 Channel 的子类, 提供了异步读取文件的能力.

来源: https://www.cnblogs.com/volcano-liu/p/11220397.html


与本文相关文章

  1. Java NIO 之拥抱 Path 和 Files
  2. Java NIO 学习系列四: NIO 和 IO 对比
  3. Java NIO系列教程（八） SocketChannel
  4. Java NIO 分析 (7): NIO 核心之 Channel,Buffer 和 Selector 简介
  5. 浅析 Java NIO
  6. java nio 原理 Java : NIO
  7. Java NIO.2 系列文章之异步通道 API 入门
  8. java NIO 深入学习
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1