Java Files类

介绍

Java 7引入的Files类是Java NIO包中的核心组件，提供了一套强大、灵活且现代化的文件操作API。与传统的java.io.File类相比，Files类提供了更丰富的功能，包括处理符号链接的能力、更好的异常处理、更高的性能以及更丰富的文件属性支持。

Files类与Path接口紧密配合，共同构成了Java现代文件处理的基础。Files类中的所有方法都是静态的，这意味着你无需创建Files实例就能使用其功能。

Files类的基本操作

检查文件和目录

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class FilesBasics {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        
        // 检查文件是否存在
        boolean exists = Files.exists(path);
        System.out.println("文件存在: " + exists);
        
        // 检查是否为常规文件
        boolean isRegularFile = Files.isRegularFile(path);
        System.out.println("是常规文件: " + isRegularFile);
        
        // 检查是否为目录
        boolean isDirectory = Files.isDirectory(path);
        System.out.println("是目录: " + isDirectory);
        
        // 检查文件是否可读
        boolean isReadable = Files.isReadable(path);
        System.out.println("文件可读: " + isReadable);
    }
}

输出(假设文件存在且是常规文件):

文件存在: true
是常规文件: true
是目录: false
文件可读: true

创建文件和目录

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CreateFileAndDirectory {
    public static void main(String[] args) {
        try {
            // 创建新文件
            Path newFile = Paths.get("newfile.txt");
            if (!Files.exists(newFile)) {
                Files.createFile(newFile);
                System.out.println("文件已创建: " + newFile);
            }
            
            // 创建目录
            Path newDir = Paths.get("newdir");
            if (!Files.exists(newDir)) {
                Files.createDirectory(newDir);
                System.out.println("目录已创建: " + newDir);
            }
            
            // 创建多级目录
            Path deepDir = Paths.get("path/to/deep/directory");
            if (!Files.exists(deepDir)) {
                Files.createDirectories(deepDir);
                System.out.println("多级目录已创建: " + deepDir);
            }
        } catch (IOException e) {
            System.out.println("发生错误: " + e.getMessage());
        }
    }
}

输出:

文件已创建: newfile.txt
目录已创建: newdir
多级目录已创建: path/to/deep/directory

文件读写操作

读取文件内容

Files类提供了多种读取文件内容的方法，从简单的一次性读取到逐行处理大文件。

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;
import java.util.stream.Stream;

public class ReadFileExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        
        try {
            // 一次读取所有内容到字节数组
            byte[] bytes = Files.readAllBytes(path);
            System.out.println("文件大小: " + bytes.length + " 字节");
            
            // 一次读取所有行到List
            List<String> lines = Files.readAllLines(path);
            System.out.println("\n所有行内容:");
            for (int i = 0; i < lines.size(); i++) {
                System.out.println((i + 1) + ": " + lines.get(i));
            }
            
            // 使用Stream API处理大文件
            System.out.println("\n使用Stream API逐行处理:");
            try (Stream<String> lineStream = Files.lines(path)) {
                lineStream.forEach(line -> System.out.println(line));
            }
        } catch (IOException e) {
            System.out.println("读取文件错误: " + e.getMessage());
        }
    }
}

提示

对于大文件，推荐使用Files.lines()方法，它返回一个Stream并允许延迟处理，避免一次性将整个文件加载到内存中。

写入文件内容

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class WriteFileExample {
    public static void main(String[] args) {
        Path path = Paths.get("output.txt");
        
        try {
            // 写入字节数组
            String content = "Hello, Files API!";
            Files.write(path, content.getBytes());
            System.out.println("内容已写入文件");
            
            // 写入多行内容
            List<String> lines = Arrays.asList(
                "这是第一行",
                "这是第二行",
                "这是第三行"
            );
            Files.write(path, lines);
            System.out.println("多行已写入文件");
            
            // 追加内容
            String appendData = "这是追加的内容";
            Files.write(path, appendData.getBytes(), StandardOpenOption.APPEND);
            System.out.println("内容已追加到文件");
        } catch (IOException e) {
            System.out.println("写入文件错误: " + e.getMessage());
        }
    }
}

文件复制、移动和删除

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.io.IOException;

public class FileOperationsExample {
    public static void main(String[] args) {
        try {
            // 创建一个源文件用于演示
            Path source = Paths.get("source.txt");
            Files.writeString(source, "这是源文件内容");
            
            // 复制文件
            Path target = Paths.get("target.txt");
            Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已复制");
            
            // 移动(重命名)文件
            Path moved = Paths.get("moved.txt");
            Files.move(target, moved, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("文件已移动/重命名");
            
            // 删除文件
            Files.delete(source);
            System.out.println("源文件已删除");
            
            // 如果文件存在则删除，不存在则不执行任何操作
            boolean deleted = Files.deleteIfExists(Paths.get("nonexistent.txt"));
            System.out.println("文件删除结果: " + deleted);
        } catch (IOException e) {
            System.out.println("操作错误: " + e.getMessage());
        }
    }
}

文件属性操作

Files类提供了多种方法来读取和修改文件的属性，如大小、权限和时间戳等。

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.Set;

public class FileAttributesExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        
        try {
            // 确保文件存在
            if (!Files.exists(path)) {
                Files.writeString(path, "属性测试内容");
            }
            
            // 获取基本文件属性
            BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
            System.out.println("创建时间: " + attrs.creationTime());
            System.out.println("最后访问时间: " + attrs.lastAccessTime());
            System.out.println("最后修改时间: " + attrs.lastModifiedTime());
            System.out.println("文件大小: " + attrs.size() + " 字节");
            System.out.println("是目录? " + attrs.isDirectory());
            System.out.println("是常规文件? " + attrs.isRegularFile());
            System.out.println("是符号链接? " + attrs.isSymbolicLink());
            
            // 获取和设置最后修改时间
            FileTime lastModified = Files.getLastModifiedTime(path);
            System.out.println("最后修改时间: " + lastModified);
            
            // 更新最后修改时间为当前时间
            Files.setLastModifiedTime(path, FileTime.fromMillis(System.currentTimeMillis()));
            System.out.println("已更新最后修改时间");
            
            // 获取和修改文件权限(POSIX文件系统)
            try {
                Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(path);
                System.out.println("当前权限: " + permissions);
                
                // 添加组写入权限
                permissions.add(PosixFilePermission.GROUP_WRITE);
                Files.setPosixFilePermissions(path, permissions);
                System.out.println("已更新权限");
            } catch (UnsupportedOperationException e) {
                System.out.println("此文件系统不支持POSIX权限");
            }
            
        } catch (IOException e) {
            System.out.println("文件属性操作错误: " + e.getMessage());
        }
    }
}

遍历目录

Files类提供了强大的目录遍历功能，无论是简单遍历还是复杂的递归处理，都能轻松实现。

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class DirectoryTraversalExample {
    public static void main(String[] args) {
        Path dir = Paths.get(".");  // 当前目录
        
        try {
            // 简单列出目录内容
            System.out.println("当前目录内容:");
            try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
                for (Path entry : stream) {
                    System.out.println(entry.getFileName());
                }
            }
            
            // 使用过滤器列出特定文件
            System.out.println("\n仅列出.java文件:");
            try (DirectoryStream<Path> stream = 
                    Files.newDirectoryStream(dir, "*.java")) {
                for (Path entry : stream) {
                    System.out.println(entry.getFileName());
                }
            }
            
            // 使用walk方法递归遍历目录树
            System.out.println("\n递归列出所有.txt文件:");
            try (Stream<Path> stream = Files.walk(dir)) {
                stream.filter(path -> path.toString().endsWith(".txt"))
                      .forEach(path -> System.out.println(path));
            }
            
            // 使用find方法根据条件查找文件
            System.out.println("\n查找大于1KB的文件:");
            try (Stream<Path> stream = Files.find(dir, 3,  // 最大深度为3
                    (path, attr) -> attr.isRegularFile() && attr.size() > 1024)) {
                stream.forEach(path -> System.out.println(path));
            }
            
        } catch (IOException e) {
            System.out.println("目录遍历错误: " + e.getMessage());
        }
    }
}

实际应用案例

案例1：文件备份工具

下面是一个简单的文件备份工具，它会复制源目录下的所有内容到备份目录，并添加时间戳：

import java.nio.file.*;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.stream.Stream;

public class FileBackupTool {
    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("用法: FileBackupTool <源目录>");
            return;
        }
        
        Path sourceDir = Paths.get(args[0]);
        
        // 验证源目录
        if (!Files.exists(sourceDir) || !Files.isDirectory(sourceDir)) {
            System.out.println("错误: 源目录不存在或不是一个目录");
            return;
        }
        
        // 创建带时间戳的备份目录名
        String timestamp = LocalDateTime.now().format(
            DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        Path backupDir = Paths.get(sourceDir.getParent().toString(), 
                               sourceDir.getFileName() + "_backup_" + timestamp);
        
        try {
            // 创建备份目录
            Files.createDirectories(backupDir);
            System.out.println("创建备份目录: " + backupDir);
            
            // 执行备份
            try (Stream<Path> paths = Files.walk(sourceDir)) {
                paths.forEach(source -> {
                    Path destination = backupDir.resolve(sourceDir.relativize(source));
                    try {
                        if (Files.isDirectory(source)) {
                            if (!Files.exists(destination)) {
                                Files.createDirectory(destination);
                            }
                        } else {
                            Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);
                        }
                    } catch (IOException e) {
                        System.out.println("备份文件失败: " + source + " -> " + e.getMessage());
                    }
                });
            }
            
            System.out.println("备份完成!");
            
        } catch (IOException e) {
            System.out.println("备份过程中发生错误: " + e.getMessage());
        }
    }
}

案例2：日志文件分析器

以下是一个简单的日志文件分析工具，它可以处理大型日志文件，统计错误和警告的出现次数：

import java.nio.file.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

public class LogAnalyzer {
    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("用法: LogAnalyzer <日志文件路径>");
            return;
        }
        
        Path logFile = Paths.get(args[0]);
        
        // 验证文件
        if (!Files.exists(logFile) || !Files.isRegularFile(logFile)) {
            System.out.println("错误: 日志文件不存在或不是常规文件");
            return;
        }
        
        // 定义日志级别的正则表达式模式
        Pattern logLevelPattern = Pattern.compile("\\[(ERROR|WARN|INFO|DEBUG)\\]");
        
        // 计数器
        Map<String, Integer> logLevelCounts = new HashMap<>();
        logLevelCounts.put("ERROR", 0);
        logLevelCounts.put("WARN", 0);
        logLevelCounts.put("INFO", 0);
        logLevelCounts.put("DEBUG", 0);
        
        try {
            // 使用Files.lines()高效处理大文件
            try (Stream<String> lines = Files.lines(logFile)) {
                lines.forEach(line -> {
                    Matcher matcher = logLevelPattern.matcher(line);
                    if (matcher.find()) {
                        String logLevel = matcher.group(1);
                        logLevelCounts.put(logLevel, logLevelCounts.get(logLevel) + 1);
                    }
                });
            }
            
            // 输出统计结果
            System.out.println("日志文件分析结果: " + logFile.getFileName());
            System.out.println("---------------------------");
            System.out.println("ERROR: " + logLevelCounts.get("ERROR"));
            System.out.println("WARN: " + logLevelCounts.get("WARN"));
            System.out.println("INFO: " + logLevelCounts.get("INFO"));
            System.out.println("DEBUG: " + logLevelCounts.get("DEBUG"));
            System.out.println("---------------------------");
            int total = logLevelCounts.values().stream().mapToInt(Integer::intValue).sum();
            System.out.println("总日志条目: " + total);
            
        } catch (IOException e) {
            System.out.println("分析日志文件时出错: " + e.getMessage());
        }
    }
}

总结

Java NIO的Files类为文件操作提供了一套现代化、高效且功能丰富的API。通过本教程，我们已经了解了：

Files类的基础知识和它与Path接口的关系
如何检查、创建、读写、复制、移动和删除文件
如何操作文件属性和权限
如何高效地遍历和处理目录树
实际应用场景中如何使用Files类

Files类的操作是原子性的，这意味着对于简单的文件操作，Files类通常是首选的方式，而不是旧的IO类。此外，Files类提供了更好的异常处理机制，大多数方法都会抛出IOException，这使得错误处理变得更加清晰和一致。

练习

文件复制工具: 创建一个程序，接收两个命令行参数（源文件和目标文件），并使用Files类复制文件。确保处理文件已存在的情况。
目录大小计算器: 编写一个程序，计算指定目录的总大小（包括所有子目录和文件）。
文本文件合并器: 创建一个应用程序，将多个文本文件的内容合并到一个输出文件中，每个源文件的内容前应添加文件名作为标题。
文件类型统计器: 编写一个程序，扫描目录并统计不同文件类型（基于扩展名）的数量，然后显示排序后的结果。

附加资源

Java官方文档 - Files类
Java NIO教程 - Oracle
《Java NIO编程》- Ron Hitchens (O'Reilly)
《Java核心技术》- 凯S.霍斯特曼 (Cay S. Horstmann)

介绍​

Files类的基本操作​

检查文件和目录​

创建文件和目录​

文件读写操作​

读取文件内容​

写入文件内容​

文件复制、移动和删除​

文件属性操作​

遍历目录​

实际应用案例​

案例1：文件备份工具​

案例2：日志文件分析器​

总结​

练习​

附加资源​

介绍