首页 > 软件编程 > Java > Java Files和Paths的使用demo详解

Java Files和Paths的使用demo详解

福牛 3月 31, 2023 37 0

前言

Java Files和Paths是Java 7中引入的新API，用于处理文件和目录。Files类提供了许多有用的静态方法来操作文件和目录，而Path类则表示文件系统中的路径。

创建文件和目录

在Java中创建文件和目录非常简单。我们可以使用Files类的createFile()方法和createDirectory()方法来创建文件和目录
示例：

  1. import java.nio.file.Files;
  2. import java.nio.file.Path;
  3. import java.nio.file.Paths;
  4. import java.io.IOException;
  5.  
  6. public class CreateFileAndDirectory {
  7.      public static void main(String[] args) throws IOException {
  8.      //文件
  9.          Path pathToFile = Paths.get(“example.txt”);
  10.          //目录
  11.          Path pathToDir = Paths.get(“exampleDir”);
  12.          //多级目录
  13.          Path pathDirectories = Paths.get(“java\exampleDir\pathDirectories\dir”);
  14.  
  15.          // 创建文件
  16.          try {
  17.          Files.createFile(pathToFile);
  18.              } catch (IOException e) {
  19.              throw new RuntimeException(e);
  20.          }
  21.  
  22.          // 创建目录
  23.          try {
  24.          Files.createDirectory(pathToDir);
  25.          } catch (IOException e) {
  26.                  throw new RuntimeException(e);
  27.          }
  28.  
  29.          //创建多级目录
  30.              try {
  31.                  Files.createDirectories(pathDirectories);
  32.          } catch (IOException e) {
  33.              throw new RuntimeException(e);
  34.          }
  35.      }
  36. }
  37.  

上面的代码会创建一个名为“example.txt”的文件和一个名为“exampleDir”的目录。如果文件或目录已经存在，这些方法将抛出异常。
createDirectories方法会创建多级目录，上级目录不存在的话，直接创建。

写入文件

Java提供了多种方式来写入文件。我们可以使用Files类的write()方法来将数据写入文件。

示例：

  1. import java.nio.file.Files;
  2. import java.nio.file.Path;
  3. import java.nio.file.Paths;
  4. import java.io.IOException;
  5. import java.util.Arrays;
  6.  
  7. public class WriteToFile {
  8.      public static void main(String[] args) throws IOException {
  9.          Path path = Paths.get(“example.txt”);
  10.  
  11.          // 写入字节数组
  12.          byte[] bytes = “Hello, world!”.getBytes();
  13.          try {
  14.              Files.write(path, bytes);
  15.          } catch (IOException e) {
  16.              throw new RuntimeException(e);
  17.          }
  19.  
  20.          // 写入字符串
  21.          String text = “Hello, world!”;
  22.          try {
  23.              Files.write(path, text.getBytes());
  24.          } catch (IOException e) {
  25.              throw new RuntimeException(e);
  26.          }
  28.  
  29.          // 写入字符串列表
  30.          Iterable<String> lines = Arrays.asList(“line 1”, “line 2”, “line 3”);
  31.              try {
  32.              Files.write(path, lines);
  33.          } catch (IOException e) {
  34.              throw new RuntimeException(e);
  35.          }
  36.      }
  37. }

上面的代码将数据写入“example.txt”文件。我们可以使用write()方法将字节数组、字符串或字符串列表写入文件。

读取文件

Java提供了多种方式来读取文件。我们可以使用Files类的readAllBytes()方法、readAllLines()方法或newBufferedReader()方法来读取文件。

  1. import java.nio.file.Files;
  2. import java.nio.file.Path;
  3. import java.nio.file.Paths;
  4. import java.io.IOException;
  5. import java.util.List;
  6.  
  7. public class ReadFromFile {
  8.      public static void main(String[] args) throws IOException {
  9.          Path path = Paths.get(“example.txt”);
  10.  
  11.          // 读取字节数组
  12.          byte[] bytes = Files.readAllBytes(path);
  13.          System.out.println(new String(bytes));
  14.  
  15.          // 读取字符串列表
  16.          List<String> lines = Files.readAllLines(path);
  17.  
  18.          // 使用BufferedReader读取文件
  19.          BufferedReader reader = Files.newBufferedReader(path);
  20.          String line = null;
  21.          while ((line = reader.readLine()) != null

删除文件或目录

删除文件或目录可以使用Files类的delete()方法。

  1. // 删除一个文件
  2. Path fileToDeletePath = Paths.get(“fileToDelete.txt”);
  3. try {
  4.      Files.delete(fileToDeletePath);
  5.      System.out.println(“文件删除成功”);
  6. } catch (IOException e) {
  7.      System.out.println(“文件删除失败”);
  8. }
  9.  
  10. // 删除一个目录
  11. Path dirToDeletePath = Paths.get(“dirToDelete”);
  12. try {
  13.      Files.delete(dirToDeletePath);
  14.      System.out.println(“目录删除成功”);
  15. } catch (IOException e) {
  16.      System.out.println(“目录删除失败”);
  17. }
  18.  
  19.  
  20. //如果文件存在才删除，不会抛出异常
  21.      try {
  22.      //返回布尔值
  23.          Files.deleteIfExists(“dirToDelete/dir”);
  24.      } catch (IOException e) {
  25.          throw new RuntimeException(e);
  26.      }

复制文件

  1. // 复制一个文件
  2. //资源地址
  3. Path sourceFilePath = Paths.get(“sourceFile.txt”);
  4. //目标地址
  5. Path targetFilePath = Paths.get(“targetFile.txt”);
  6.  
  7.  
  8. try {
  9.      Files.copy(sourceFilePath, targetFilePath,StandardCopyOption.REPLACE_EXISTING);
  10.      System.out.println(“文件复制成功”);
  11. } catch (IOException e) {
  12.      System.out.println(“文件复制失败：” + e.getMessage());
  13. }

复制目录

  1. // 复制一个目录
  2. Path sourceDirPath = Paths.get(“C:/Users/username/Desktop/sourceDir”);
  3. Path targetDirPath = Paths.get(“C:/Users/username/Desktop/targetDir”);
  4. try {
  5. //CopyFileVisitor是需要自己实现的
  6.  
  7.      Files.walkFileTree(sourceDirPath, new CopyFileVisitor(sourceDirPath, targetDirPath));
  8.      System.out.println(“目录复制成功”);
  9. } catch (IOException e) {
  10.      System.out.println(“目录复制失败：” + e.getMessage());
  11. }

CopyFileVisitor

  1. import java.io.IOException;
  2. import java.nio.file.*;
  3. import java.nio.file.attribute.BasicFileAttributes;
  4.  
  5. public class CopyFileVisitor extends SimpleFileVisitor<Path> {
  6.      private final Path sourceDir;
  7.      private final Path targetDir;
  8.  
  9.      public CopyFileVisitor(Path sourceDir, Path targetDir) {
  10.          this.sourceDir = sourceDir;
  11.          this.targetDir = targetDir;
  12.      }
  13.  
  14.      @Override
  15.      public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
  16.          Path targetPath = targetDir.resolve(sourceDir.relativize(dir));
  17.          try {
  18.              Files.copy(dir, targetPath);
  19.          } catch (FileAlreadyExistsException e) {
  20.              if (!Files.isDirectory(targetPath)) {
  21.                  throw e;
  22.              }
  23.          }
  24.          return FileVisitResult.CONTINUE;
  25.      }
  26.  
  27.      @Override
  28.      public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
  29.          Path targetPath = targetDir.resolve(sourceDir.relativize(file));
  30.          Files.copy(file, targetPath, StandardCopyOption.REPLACE_EXISTING);
  31.          return FileVisitResult.CONTINUE;
  32.      }
  33. }

在preVisitDirectory()方法中，我们将源目录下的子目录逐个创建到目标目录中。在创建过程中，我们使用Files.copy()方法将目录复制到目标目录中。由于目标目录可能已经存在，因此我们在Files.copy()方法中使用了FileAlreadyExistsException异常进行处理。

在visitFile()方法中，我们将源目录下的文件逐个复制到目标目录中。在复制过程中，我们使用Files.copy()方法将文件复制到目标目录中，并使用StandardCopyOption.REPLACE_EXISTING选项替换现有文件。

移动或重命名

  1.      try {
  2.      //这个操作可以做移动或重命名
  3.          Files.move(Paths.get(“source.txt”),Paths.get(“target.txt”), StandardCopyOption.REPLACE_EXISTING);
  4.          } catch (IOException e) {
  5.              throw new RuntimeException(e);
  6.          }

遍历目录

  1.      Path start = Paths.get(“sourceDir”);
  2.          int maxDepth = Integer.MAX_VALUE;
  3.  
  4.          try {
  5.              Files.walk(start, maxDepth).forEach(System.out::println);
  6.          } catch (IOException e) {
  7.              throw new RuntimeException(e);
  8.          }

该方法接受三个参数：

  • start：表示要遍历的根目录的路径。
  • maxDepth：表示要遍历的最大深度。如果maxDepth为0，则只遍历根目录，不遍历其子目录。如果maxDepth为正整数，则遍历根目录和所有深度不超过maxDepth的子目录。如果maxDepth为负数，则遍历根目录和所有子目录。
  • options：表示遍历选项。可选项包括FileVisitOption.FOLLOW_LINKS和FileVisitOption.NOFOLLOW_LINKS。
  • 如果选择FOLLOW_LINKS选项，则遍历符号链接指向的目录；
  • 如果选择NOFOLLOW_LINKS选项，则遍历符号链接本身

获取文件属性

  1.      try {
  2.  
  3.              Path path = Paths.get(“F:\\java\\2.txt”).toAbsolutePath();
  4.              System.out.println(“文件是否存在: “ + Files.exists(path));
  5.              System.out.println(“是否是目录: “ + Files.isDirectory(path));
  6.              System.out.println(“是否是可执行文件: “ + Files.isExecutable(path));
  7.              System.out.println(“是否可读: “ + Files.isReadable(path));
  8.              System.out.println(“判断是否是一个文件: “ + Files.isRegularFile(path));
  9.              System.out.println(“是否可写: “ + Files.isWritable(path));
  10.              System.out.println(“文件是否不存在: “ + Files.notExists(path));
  11.              System.out.println(“文件是否隐藏: “ + Files.isHidden(path));
  12.  
  13.              System.out.println(“文件大小: “ + Files.size(path));
  14.              System.out.println(“文件存储在SSD还是HDD: “ + Files.getFileStore(path));
  15.              System.out.println(“文件修改时间：” + Files.getLastModifiedTime(path));
  16.              System.out.println(“文件拥有者： “ + Files.getOwner(path));
  17.              System.out.println(“文件类型: “ + Files.probeContentType(path));
  18.          } catch (IOException e) {
  19.              throw new RuntimeException(e);
  20.          }

到此这篇关于Java Files和Paths的使用详解的文章就介绍到这了,更多相关java Files和Paths使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论