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

标签：Files Paths java 文件 System file Path

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. 文件和目录的创建

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

解释

创建目录和文件：使用 Files.createDirectory 和 Files.createFile 方法创建目录和文件。
写入和读取文件：使用 Files.write 将字符串写入文件，使用 Files.readAllLines 读取文件内容。
复制和移动文件：使用 Files.copy 复制文件，使用 Files.move 移动文件。
获取文件属性：使用 Files.size 和 Files.getLastModifiedTime 获取文件的大小和最后修改时间。
遍历目录：使用 Files.newDirectoryStream 遍历目录中的文件。
删除文件和目录：使用 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 紧密集成，支持高级文件操作和属性管理。

最佳实践

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

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

标签：Files,Paths,java,文件,System,file,Path
From： https://www.cnblogs.com/xxctx/p/18464728

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

1. 概述

2. Path 接口

概述

主要功能和方法

路径创建与解析

路径信息

路径转换

路径比较

其他方法

示例代码

3. Paths 类

概述

创建 Path 实例

注意事项

4. Files 类

概述

主要功能和方法

1. 文件和目录的创建

2. 文件和目录的删除

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

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

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

6. 目录的遍历和查找

示例代码

创建文件和目录

写入和读取文件内容

复制和移动文件

删除文件和目录

遍历目录内容

获取和设置文件属性

注意事项

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

综合示例

解释

6. 高级功能和最佳实践

1. 使用文件过滤器

2. 使用文件遍历器

3. 异步文件操作

4. 处理文件系统差异

5. 错误处理和资源管理

6. 性能优化

7. 总结

最佳实践

相关文章

赞助商

阅读排行

2. `Path` 接口

3. `Paths` 类

创建 `Path` 实例

4. `Files` 类

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