java 文件的操作（Path、Paths、Files）

文章java 文件的操作（Path、Paths、Files）分享给大家，欢迎收藏Java资料网，专注分享技术知识

Path、Paths 和 Files 是 Java NIO（New I/O）文件处理系统中的核心组件，它们提供了比传统 java.io.File 更加灵活和高效的文件操作方式。

1. 概述

随着 Java 7 引入 NIO.2（即 Java New I/O 2），文件处理得到了显著改进。Path、Paths 和 Files 是 NIO.2 中用于文件和目录操作的三个关键组件：

• Path：表示文件系统中的路径，类似于传统的 java.io.File，但更加灵活和功能丰富。
• Paths：一个工具类，提供静态方法用于创建 Path 实例。
• Files：一个实用工具类，提供了大量静态方法用于执行文件和目录的各种操作，如创建、删除、复制、移动、读取和写入等。

相比传统的 File 类，NIO.2 提供了更好的错误处理、更丰富的功能以及对不同文件系统的支持。

---

2. Path 接口

概述

Path 是一个接口，位于 java.nio.file 包中，用于表示文件系统中的路径。它提供了一种平台无关的方式来表示文件和目录的路径，并支持丰富的路径操作。

主要功能和方法

以下是 Path 接口的一些关键方法和功能：

路径创建与解析

• Path resolve(String other)：将给定的路径字符串解析为当前路径的子路径。
• Path resolve(Path other)：将给定的 Path 解析为当前路径的子路径。
• Path relativize(Path other)：计算从当前路径到给定路径的相对路径。

路径信息

• String getFileName()：返回路径中的文件名部分。
• Path getParent()：返回路径的父路径。
• Path getRoot()：返回路径的根组件。
• int getNameCount()：返回路径中的名称元素数。
• Path getName(int index)：返回指定索引的名称元素。

路径转换

• Path toAbsolutePath()：将相对路径转换为绝对路径。
• Path normalize()：规范化路径，去除冗余的名称元素，如 "." 和 ".."。

路径比较

• boolean startsWith(String other)：判断路径是否以给定的路径字符串开头。
• boolean endsWith(String other)：判断路径是否以给定的路径字符串结尾。
• boolean equals(Object other)：判断两个路径是否相等。

其他方法

• Iterator<Path> iterator()：返回一个迭代器，用于遍历路径中的名称元素。
• String toString()：返回路径的字符串表示。
• String toAbsolutePath().toString()：返回绝对路径的字符串表示。

示例代码

import java.nio.file.Path;
import java.nio.file.Paths;

public class PathExample {
    public static void main(String[] args) {
        // 创建 Path 实例
        Path path = Paths.get("src", "main", "java", "Example.java");
        
        // 获取文件名
        System.out.println("文件名: " + path.getFileName());
        
        // 获取父路径
        System.out.println("父路径: " + path.getParent());
        
        // 获取根路径
        System.out.println("根路径: " + path.getRoot());
        
        // 规范化路径
        Path normalizedPath = path.normalize();
        System.out.println("规范化路径: " + normalizedPath);
        
        // 转换为绝对路径
        Path absolutePath = path.toAbsolutePath();
        System.out.println("绝对路径: " + absolutePath);
        
        // 解析子路径
        Path resolvedPath = path.resolve("subdir/File.txt");
        System.out.println("解析后的路径: " + resolvedPath);
        
        // 计算相对路径
        Path basePath = Paths.get("src/main");
        Path relativePath = basePath.relativize(path);
        System.out.println("相对路径: " + relativePath);
        
        // 遍历路径中的元素
        System.out.println("路径元素:");
        for (Path element : path) {
            System.out.println(element);
        }
    }
}

输出示例：

文件名: Example.java
父路径: src/main/java
根路径: null
规范化路径: src/main/java/Example.java
绝对路径: /Users/username/project/src/main/java/Example.java
解析后的路径: src/main/java/Example.java/subdir/File.txt
相对路径: java/Example.java
路径元素:
src
main
java
Example.java

---

3. Paths 类

概述

Paths 是一个最终类，位于 java.nio.file 包中，提供了静态方法用于创建 Path 实例。它简化了 Path 对象的创建过程，使代码更加简洁和易读。

创建 Path 实例

import java.nio.file.Path;
import java.nio.file.Paths;
import java.net.URI;

public class PathsExample {
    public static void main(String[] args) {
        // 使用多个字符串片段创建路径
        Path path1 = Paths.get("C:", "Users", "Public", "Documents");
        System.out.println("路径1: " + path1);
        
        // 使用单个字符串创建路径
        Path path2 = Paths.get("/home/user/docs");
        System.out.println("路径2: " + path2);
        
        // 使用相对路径创建路径
        Path path3 = Paths.get("src/main/java/Example.java");
        System.out.println("路径3: " + path3);
          
        // 组合路径片段
        Path basePath = Paths.get("/home/user");
        Path combinedPath = basePath.resolve("downloads/music");
        System.out.println("组合后的路径: " + combinedPath);
    }
}

输出示例：

路径1: C:\Users\Public\Documents
路径2: /home/user/docs
路径3: src/main/java/Example.java
组合后的路径: /home/user/downloads/music

注意事项

• Paths.get(...) 方法会根据操作系统自动处理路径分隔符，无需手动指定。例如，在 Windows 上会使用 \，在 Unix/Linux 上会使用 /。

---

4. Files 类

概述

Files 是一个最终类，位于 java.nio.file 包中，提供了大量的静态方法用于执行文件和目录的各种操作。它与 Path 接口紧密集成，提供了比 java.io.File 更加丰富和高效的功能。

主要功能和方法

Files 类的方法可以大致分为以下几类：

1. 文件和目录的创建
2. 文件和目录的删除
3. 文件和目录的复制与移动
4. 文件内容的读取与写入
5. 文件属性的获取与修改
6. 目录的遍历和查找

1. 文件和目录的创建

• static Path createFile(Path path, FileAttribute<?>... attrs)：创建一个新文件。
• static Path createDirectory(Path dir, FileAttribute<?>... attrs)：创建一个新目录。
• static Path createDirectories(Path dir, FileAttribute<?>... attrs)：递归地创建目录，包括不存在的父目录。

2. 文件和目录的删除

• static void delete(Path path)：删除指定的文件或目录。如果路径是目录，则目录必须为空。
• static boolean deleteIfExists(Path path)：删除指定的文件或目录，如果存在的话。

3. 文件和目录的复制与移动

• static Path copy(Path source, Path target, CopyOption... options)：复制文件或目录。
• static Path move(Path source, Path target, CopyOption... options)：移动或重命名文件或目录。

4. 文件内容的读取与写入

• static byte[] readAllBytes(Path path)：读取文件的所有字节。
• static List<String> readAllLines(Path path, Charset cs)：按行读取文件内容。
• static Path write(Path path, byte[] bytes, OpenOption... options)：将字节数组写入文件。
• static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)：将行写入文件。

5. 文件属性的获取与修改

• static boolean exists(Path path, LinkOption... options)：检查路径是否存在。
• static boolean isDirectory(Path path, LinkOption... options)：判断路径是否是目录。
• static boolean isRegularFile(Path path, LinkOption... options)：判断路径是否是常规文件。
• static long size(Path path)：获取文件的大小（以字节为单位）。
• static FileTime getLastModifiedTime(Path path, LinkOption... options)：获取文件的最后修改时间。
• static Path setLastModifiedTime(Path path, FileTime time)：设置文件的最后修改时间。

6. 目录的遍历和查找

• static DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)：打开一个目录流，遍历目录中的文件和子目录。
• static Stream<Path> walk(Path start, FileVisitOption... options)：递归地遍历目录树。
• static Stream<Path> list(Path dir)：列出目录中的内容，不进行递归。

示例代码

以下是一些常见的 Files 类方法的示例：

创建文件和目录

import java.nio.file.*;
import java.io.IOException;

public class FilesCreateExample {
    public static void main(String[] args) {
        Path directory = Paths.get("exampleDir");
        Path file = directory.resolve("exampleFile.txt");
        
        try {
            // 创建目录
            if (!Files.exists(directory)) {
                Files.createDirectory(directory);
                System.out.println("目录已创建: " + directory);
            }
            
            // 创建文件
            if (!Files.exists(file)) {
                Files.createFile(file);
                System.out.println("文件已创建: " + file);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

写入和读取文件内容

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class FilesReadWriteExample {
    public static void main(String[] args) {
        Path file = Paths.get("exampleDir/exampleFile.txt");
        
        // 写入字节数组到文件
        String content = "Hello, Java NIO!";
        try {
            Files.write(file, content.getBytes(), StandardOpenOption.WRITE);
            System.out.println("数据已写入文件");
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 读取所有字节
        try {
            byte[] data = Files.readAllBytes(file);
            System.out.println("文件内容 (字节): " + new String(data));
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 按行读取文件内容
        try {
            List<String> lines = Files.readAllLines(file, StandardOpenOption.READ);
            System.out.println("文件内容 (按行):");
            for (String line : lines) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

复制和移动文件

import java.nio.file.*;
import java.io.IOException;

public class FilesCopyMoveExample {
    public static void main(String[] args) {
        Path source = Paths.get("exampleDir/exampleFile.txt");
        Path targetCopy = Paths.get("exampleDir/copyOfExampleFile.txt");
        Path targetMove = Paths.get("exampleDir/movedExampleFile.txt");
        
        try {
            // 复制文件
            Files.copy(source, targetCopy, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已复制到: " + targetCopy);
            
            // 移动文件
            Files.move(source, targetMove, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已移动到: " + targetMove);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

删除文件和目录

import java.nio.file.*;
import java.io.IOException;

public class FilesDeleteExample {
    public static void main(String[] args) {
        Path file = Paths.get("exampleDir/movedExampleFile.txt");
        Path directory = Paths.get("exampleDir");
        
        try {
            // 删除文件
            if (Files.deleteIfExists(file)) {
                System.out.println("文件已删除: " + file);
            }
            
            // 删除目录（目录必须为空）
            if (Files.deleteIfExists(directory)) {
                System.out.println("目录已删除: " + directory);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

遍历目录内容

import java.nio.file.*;
import java.io.IOException;

public class FilesListDirectoryExample {
    public static void main(String[] args) {
        Path directory = Paths.get("exampleDir");
        
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
            System.out.println("目录中的文件:");
            for (Path entry : stream) {
                System.out.println(entry.getFileName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取和设置文件属性

import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;

public class FilesAttributesExample {
    public static void main(String[] args) {
        Path file = Paths.get("exampleDir/exampleFile.txt");
        
        try {
            // 获取文件大小
            long size = Files.size(file);
            System.out.println("文件大小: " + size + " 字节");
            
            // 获取最后修改时间
            FileTime lastModifiedTime = Files.getLastModifiedTime(file);
            System.out.println("最后修改时间: " + lastModifiedTime);
            
            // 设置最后修改时间为当前时间
            FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
            Files.setLastModifiedTime(file, newTime);
            System.out.println("最后修改时间已更新");
            
            // 检查文件是否存在
            boolean exists = Files.exists(file);
            System.out.println("文件存在: " + exists);
            
            // 检查是否为目录
            boolean isDirectory = Files.isDirectory(file);
            System.out.println("是目录: " + isDirectory);
            
            // 检查是否为常规文件
            boolean isRegularFile = Files.isRegularFile(file);
            System.out.println("是常规文件: " + isRegularFile);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意事项

• 异常处理：大多数 Files 类的方法都会抛出 IOException，因此在使用这些方法时需要适当的异常处理。
• 原子操作：某些方法（如 Files.move）可以进行原子操作，确保文件操作的完整性。
• 性能考虑：对于大文件或大量文件操作，考虑使用流式处理方法（如 Files.newBufferedReader 和 Files.newBufferedWriter）以提高性能和减少内存消耗。

---

5. Path、Paths 和 Files 的协同使用

这三个组件通常一起使用，以实现对文件和目录的全面操作。以下是一个综合示例，展示了如何使用 Path、Paths 和 Files 完成常见的文件操作任务。

综合示例

import java.nio.file.*;
import java.io.IOException;
import java.util.List;
import java.nio.charset.StandardCharsets;

public class ComprehensiveFileOperations {
    public static void main(String[] args) {
        Path directory = Paths.get("comprehensiveExampleDir");
        Path file = directory.resolve("exampleFile.txt");
        Path copyFile = directory.resolve("copyOfExampleFile.txt");
        Path movedFile = directory.resolve("movedExampleFile.txt");
        
        try {
            // 1. 创建目录
            if (!Files.exists(directory)) {
                Files.createDirectory(directory);
                System.out.println("目录已创建: " + directory);
            }
            
            // 2. 创建文件
            if (!Files.exists(file)) {
                Files.createFile(file);
                System.out.println("文件已创建: " + file);
            }
            
            // 3. 写入数据到文件
            String content = "Hello, Comprehensive Java NIO!";
            Files.write(file, content.getBytes(StandardCharsets.UTF_8), StandardOpenOption.WRITE);
            System.out.println("数据已写入文件: " + file);
            
            // 4. 读取文件内容
            List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
            System.out.println("文件内容:");
            for (String line : lines) {
                System.out.println(line);
            }
            
            // 5. 复制文件
            Files.copy(file, copyFile, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已复制到: " + copyFile);
            
            // 6. 移动文件
            Files.move(file, movedFile, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已移动到: " + movedFile);
            
            // 7. 获取文件属性
            long size = Files.size(movedFile);
            FileTime lastModifiedTime = Files.getLastModifiedTime(movedFile);
            System.out.println("文件大小: " + size + " 字节");
            System.out.println("最后修改时间: " + lastModifiedTime);
            
            // 8. 遍历目录中的文件
            System.out.println("目录中的文件:");
            try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
                for (Path entry : stream) {
                    System.out.println(entry.getFileName());
                }
            }
            
            // 9. 删除文件和目录
            Files.deleteIfExists(copyFile);
            System.out.println("复制的文件已删除: " + copyFile);
            
            Files.deleteIfExists(movedFile);
            System.out.println("移动的文件已删除: " + movedFile);
            
            Files.deleteIfExists(directory);
            System.out.println("目录已删除: " + directory);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果示例：

目录已创建: comprehensiveExampleDir
文件已创建: comprehensiveExampleDir/exampleFile.txt
数据已写入文件: comprehensiveExampleDir/exampleFile.txt
文件内容:
Hello, Comprehensive Java NIO!
文件已复制到: comprehensiveExampleDir/copyOfExampleFile.txt
文件已移动到: comprehensiveExampleDir/movedExampleFile.txt
文件大小: 31 字节
最后修改时间: 2024-04-27T10:15:30Z
目录中的文件:
copyOfExampleFile.txt
movedExampleFile.txt
复制的文件已删除: comprehensiveExampleDir/copyOfExampleFile.txt
移动的文件已删除: comprehensiveExampleDir/movedExampleFile.txt
目录已删除: comprehensiveExampleDir

解释

1. 创建目录和文件：使用 Files.createDirectory 和 Files.createFile 方法创建目录和文件。
2. 写入和读取文件：使用 Files.write 将字符串写入文件，使用 Files.readAllLines 读取文件内容。
3. 复制和移动文件：使用 Files.copy 复制文件，使用 Files.move 移动文件。
4. 获取文件属性：使用 Files.size 和 Files.getLastModifiedTime 获取文件的大小和最后修改时间。
5. 遍历目录：使用 Files.newDirectoryStream 遍历目录中的文件。
6. 删除文件和目录：使用 Files.deleteIfExists 删除文件和目录。

---

6. 高级功能和最佳实践

1. 使用文件过滤器

Files.newDirectoryStream 方法支持使用过滤器来筛选目录中的文件。例如，仅列出 .txt 文件：

import java.nio.file.*;
import java.io.IOException;

public class FilesFilterExample {
    public static void main(String[] args) {
        Path directory = Paths.get("exampleDir");
        
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory, "*.txt")) {
            System.out.println("目录中的 .txt 文件:");
            for (Path entry : stream) {
                System.out.println(entry.getFileName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 使用文件遍历器

对于复杂的目录遍历，可以使用 Files.walkFileTree 方法结合 FileVisitor 接口，实现自定义的遍历逻辑。例如，查找目录中所有的 .java 文件：

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;

public class FilesWalkFileTreeExample {
    public static void main(String[] args) {
        Path startPath = Paths.get("src");
        
        try {
            Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    if (file.toString().endsWith(".java")) {
                        System.out.println("找到 Java 文件: " + file);
                    }
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 异步文件操作

虽然 Files 类主要提供同步方法，但结合 Java NIO 的异步通道（如 AsynchronousFileChannel），可以实现异步文件操作，提高性能。

import java.nio.file.*;
import java.nio.channels.*;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.concurrent.Future;

public class AsynchronousFileExample {
    public static void main(String[] args) {
        Path file = Paths.get("asyncExample.txt");
        
        try (AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(file, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
            String content = "Asynchronous File Writing in Java NIO.";
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
            
            Future<Integer> operation = asyncChannel.write(buffer, 0);
            
            while (!operation.isDone()) {
                System.out.println("正在写入文件...");
                Thread.sleep(100);
            }
            
            System.out.println("写入完成，写入字节数: " + operation.get());
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4. 处理文件系统差异

NIO.2 支持不同类型的文件系统（如本地文件系统、ZIP 文件系统等）。可以使用 FileSystem 类和相关方法来处理不同的文件系统。

import java.nio.file.*;
import java.io.IOException;

public class ZipFileSystemExample {
    public static void main(String[] args) {
        Path zipPath = Paths.get("example.zip");
        try (FileSystem zipFs = FileSystems.newFileSystem(zipPath, null)) {
            Path internalPath = zipFs.getPath("/newFile.txt");
            Files.write(internalPath, "内容写入 ZIP 文件".getBytes(), StandardOpenOption.CREATE);
            System.out.println("文件已写入 ZIP 文件");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5. 错误处理和资源管理

• 异常处理：尽量使用具体的异常类型，如 NoSuchFileException、DirectoryNotEmptyException 等，以便更精确地处理错误。
• 资源管理：使用 try-with-resources 语句自动关闭流和目录流，避免资源泄漏。

import java.nio.file.*;
import java.io.IOException;

public class ResourceManagementExample {
    public static void main(String[] args) {
        Path file = Paths.get("exampleDir/exampleFile.txt");
        
        // 使用 try-with-resources 读取文件内容
        try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. 性能优化

• 批量操作：尽量批量读取或写入数据，减少 I/O 操作的次数。
• 缓冲流：使用缓冲流（如 BufferedReader 和 BufferedWriter）提高读写性能。
• 并行处理：对于大规模文件操作，可以考虑并行处理，如使用多线程或并行流。

---

7. 总结

Path、Paths 和 Files 是 Java NIO.2 中处理文件和目录操作的核心组件，提供了比传统 java.io.File 更加现代化、灵活和高效的功能。以下是它们的主要特点和最佳使用场景：

• Path：

  • 表示文件系统中的路径，提供丰富的路径操作方法。
  • 不同于 String，提供平台无关的路径处理。

• Paths：

  • 提供静态方法 get，简化 Path 对象的创建过程。
  • 使代码更加简洁和易读。

• Files：

  • 提供大量静态方法用于执行文件和目录的各种操作，如创建、删除、复制、移动、读取、写入等。
  • 与 Path 紧密集成，支持高级文件操作和属性管理。

最佳实践

1. 优先使用 NIO.2 的类：在新的项目中，优先使用 Path、Paths 和 Files，而非 java.io.File，以获得更好的性能和更多功能。
2. 使用 try-with-resources：确保所有的流和资源在使用后被正确关闭，避免资源泄漏。
3. 处理具体异常：尽量捕获和处理具体的异常类型，以便更好地应对不同的错误情况。
4. 优化性能：对于大量或大规模的文件操作，考虑使用缓冲流、批量操作或并行处理来提高性能。
5. 利用文件过滤和遍历器：使用 DirectoryStream 和 FileVisitor 实现高效的文件过滤和目录遍历。
6. 保持路径的不可变性：Path 对象是不可变的，这有助于线程安全和代码的健壮性。

通过充分理解和运用 Path、Paths 和 Files，可以高效地处理 Java 应用中的各种文件和目录操作任务，提升代码的可维护性和性能。

文章来源:https://www.cnblogs.com/xxctx/p/18464728
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！