NIO与Files 详解

// 方式1: Paths.get()（推荐）
Path p1 = Paths.get("d:/feixiang/logs");
Path p2 = Paths.get("d:", "feixiang", "logs", "app.log");  // 可变参数
Path p3 = Paths.get("d:/feixiang", "data", "config.properties");

// 方式2: FileSystems.getDefault().getPath()
Path p4 = FileSystems.getDefault().getPath("d:/feixiang/logs");

// 方式3: 从 File 转换
File oldFile = new File("d:/feixiang/old.txt");
Path p5 = oldFile.toPath();  // File → Path
File backToFile = p5.toFile();  // Path → File

// 方式4: 相对路径
Path cwd = Paths.get("").toAbsolutePath();  // 当前工作目录

Path path = Paths.get("d:/feixiang/logs/2024/app.log");

path.getFileName();       // app.log
path.getParent();         // d:\feixiang\logs\2024
path.getRoot();           // d:\
path.getName(0);          // feixiang
path.getName(1);          // logs
path.getNameCount();      // 5 (feixiang, logs, 2024, app.log —— 不含root)

// 路径拼接
Path base = Paths.get("d:/feixiang");
Path resolved = base.resolve("logs");      // d:\feixiang\logs
Path sibling = base.resolveSibling("data"); // d:\data (替换最后一段)

// 相对化
Path abs = Paths.get("d:/feixiang/logs/app.log");
Path base2 = Paths.get("d:/feixiang");
Path relative = base2.relativize(abs);      // logs\app.log

// 规范化
Path messy = Paths.get("d:/feixiang/../feixiang/logs/./app.log");
Path clean = messy.normalize();             // d:\feixiang\logs\app.log

// 比较
path.startsWith(Paths.get("d:/feixiang")); // true
path.endsWith(Paths.get("app.log"));       // true

// 创建目录
Files.createDirectory(Paths.get("d:/feixiang/newDir"));       // 只创建最后一级
Files.createDirectories(Paths.get("d:/feixiang/a/b/c"));      // 创建所有中间目录

// 创建文件
Files.createFile(Paths.get("d:/feixiang/newFile.txt"));

// 复制
Files.copy(src, dest, StandardCopyOption.REPLACE_EXISTING);
Files.copy(src, dest, StandardCopyOption.COPY_ATTRIBUTES);

// 移动/重命名
Files.move(src, dest, StandardCopyOption.REPLACE_EXISTING);
Files.move(src, dest, StandardCopyOption.ATOMIC_MOVE);  // 原子移动

// 删除
Files.delete(path);             // 文件不存在时抛异常
Files.deleteIfExists(path);     // 文件不存在时返回false，不抛异常

Path path = Paths.get("d:/feixiang/app.log");

// 基本属性
BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
attrs.size();              // 文件大小（字节）
attrs.creationTime();      // 创建时间
attrs.lastModifiedTime();  // 最后修改时间
attrs.isDirectory();       // 是否为目录
attrs.isRegularFile();     // 是否为常规文件
attrs.isSymbolicLink();    // 是否为符号链接

// 单个属性
long size = Files.size(path);
boolean exists = Files.exists(path);
boolean isDir = Files.isDirectory(path);
boolean readable = Files.isReadable(path);
boolean writable = Files.isWritable(path);

// 设置属性
Files.setLastModifiedTime(path, FileTime.fromMillis(System.currentTimeMillis()));

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 飞翔科技 - 日志文件递归遍历与分析
 * 场景：遍历服务器日志目录，统计各月日志文件数量和总大小
 * 技术：Files.walkFileTree + SimpleFileVisitor
 * 作者：大翔
 */
public class FeixiangLogFileTraversal {

    // 统计容器
    private static final Map<String, FileStat> monthStats = new TreeMap<>();
    private static final AtomicLong totalSize = new AtomicLong(0);
    private static final AtomicLong totalFiles = new AtomicLong(0);

    public static void main(String[] args) throws IOException {
        // 1. 准备测试数据——创建模拟的日志目录结构
        prepareTestLogFiles();

        // 2. 使用 FileVisitor 遍历
        Path logRoot = Paths.get("d:/feixiang/logs");
        traverseLogs(logRoot);

        // 3. 打印统计报告
        printReport(logRoot);
    }

    /**
     * 准备模拟的测试日志文件
     */
    private static void prepareTestLogFiles() throws IOException {
        String[][] logs = {
            // {路径, 内容}
            {"2024-01/15/app.log", "INFO: 服务器启动 | 大翔登录"},
            {"2024-01/15/error.log", "ERROR: 数据库连接超时"},
            {"2024-01/20/app.log", "INFO: 备份完成"},
            {"2024-02/05/app.log", "INFO: 系统升级 | 白歌操作"},
            {"2024-02/05/debug.log", "DEBUG: 内存使用率 65%"},
            {"2024-02/14/app.log", "INFO: 情人节特别维护"},
            {"2024-02/14/access.log", "GET /api/users 200 15ms"},
            {"2024-03/01/app.log", "INFO: 月度报表生成"},
            {"2024-03/01/error.log", "WARN: 磁盘空间不足"},
            {"2024-03/15/app.log", "INFO: 服务器启动成功"},
        };

        for (String[] entry : logs) {
            Path filePath = Paths.get("d:/feixiang/logs", entry[0]);
            Files.createDirectories(filePath.getParent());
            Files.write(filePath, entry[1].getBytes("UTF-8"),
                    StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
        }
        System.out.println("[大翔] 测试日志文件已准备完成，共 " + logs.length + " 个文件\n");
    }

    /**
     * 核心：使用 Files.walkFileTree 递归遍历日志目录
     */
    public static void traverseLogs(Path startPath) throws IOException {
        System.out.println("[大翔] 开始遍历日志目录: " + startPath.toAbsolutePath());

        Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {

            /**
             * 进入目录前调用
             */
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                    throws IOException {
                System.out.println("[小崔] 进入目录: " + dir.getFileName());
                return FileVisitResult.CONTINUE;  // 继续遍历
            }

            /**
             * 访问到文件时调用
             */
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                    throws IOException {
                // 只处理 .log 文件
                if (!file.toString().endsWith(".log")) {
                    return FileVisitResult.CONTINUE;
                }

                // 解析月份 (从路径中提取 "YYYY-MM")
                String monthKey = extractMonth(file);
                if (monthKey == null) {
                    return FileVisitResult.CONTINUE;
                }

                // 更新统计
                long fileSize = attrs.size();
                totalSize.addAndGet(fileSize);
                totalFiles.incrementAndGet();

                monthStats.computeIfAbsent(monthKey, k -> new FileStat())
                          .addFile(file.getFileName().toString(), fileSize);

                System.out.printf("  [白歌] 发现日志: %s (%d bytes) [%s]%n",
                        file.getFileName(), fileSize, monthKey);

                return FileVisitResult.CONTINUE;
            }

            /**
             * 访问文件失败时调用（权限不足等）
             */
            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc)
                    throws IOException {
                System.err.println("[小崔] 无法访问文件: " + file + " - " + exc.getMessage());
                return FileVisitResult.CONTINUE;  // 继续遍历其他文件
            }

            /**
             * 离开目录后调用
             */
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
                    throws IOException {
                System.out.println("[小崔] 离开目录: " + dir.getFileName());
                if (exc != null) {
                    System.err.println("[白歌] 目录遍历异常: " + exc.getMessage());
                }
                return FileVisitResult.CONTINUE;
            }
        });

        System.out.println("[大翔] 遍历完成!\n");
    }

    /**
     * 从文件路径中提取月份 (YYYY-MM)
     */
    private static String extractMonth(Path file) {
        // 路径格式: logs/2024-01/15/app.log
        Path parent = file.getParent();   // logs/2024-01/15
        if (parent != null) {
            Path month = parent.getParent();  // logs/2024-01
            if (month != null) {
                String monthName = month.getFileName().toString();
                if (monthName.matches("\\d{4}-\\d{2}")) {
                    return monthName;
                }
            }
        }
        return null;
    }

    /**
     * 打印统计报告
     */
    private static void printReport(Path logRoot) {
        System.out.println("========================================");
        System.out.println("   飞翔科技 日志文件统计报告");
        System.out.println("   根目录: " + logRoot.toAbsolutePath());
        System.out.println("========================================");
        System.out.printf("  总文件数: %d%n", totalFiles.get());
        System.out.printf("  总大小:   %.2f KB (%d bytes)%n",
                totalSize.get() / 1024.0, totalSize.get());
        System.out.println("----------------------------------------");

        for (Map.Entry<String, FileStat> entry : monthStats.entrySet()) {
            FileStat stat = entry.getValue();
            System.out.printf("  [%s] 文件数: %d, 大小: %d bytes%n",
                    entry.getKey(), stat.fileCount, stat.totalBytes);
        }
        System.out.println("========================================");
    }

    /**
     * 内部统计类
     */
    static class FileStat {
        int fileCount = 0;
        long totalBytes = 0;
        List<String> fileNames = new ArrayList<>();

        void addFile(String name, long bytes) {
            fileCount++;
            totalBytes += bytes;
            fileNames.add(name);
        }
    }
}

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 飞翔科技 - 批量文件重命名与迁移工具
 * 场景：资源文件命名不规范，需要统一格式化
 * 功能：
 *   1. 递归遍历所有文件
 *   2. 去除文件名中的空格和特殊字符
 *   3. 统一扩展名为小写
 *   4. 按修改时间归档到分类目录
 * 作者：白歌
 */
public class FeixiangFileBatchRename {

    private static final String SOURCE_DIR = "d:/feixiang/assets_in";
    private static final String TARGET_DIR = "d:/feixiang/assets_out";

    // 重命名统计
    private static int renamedCount = 0;
    private static int copiedCount = 0;
    private static int skippedCount = 0;

    public static void main(String[] args) throws IOException {
        // 1. 准备测试文件
        prepareMessyFiles();

        // 2. 批量重命名（原地改名）
        batchRename(Paths.get(SOURCE_DIR));

        // 3. 按时间归档到目标目录
        archiveByMonth(Paths.get(SOURCE_DIR), Paths.get(TARGET_DIR));

        // 4. 对比两个目录
        compareDirectories();

        // 5. 打印报告
        printSummary();
    }

    /**
     * 准备命名混乱的测试文件
     */
    private static void prepareMessyFiles() throws IOException {
        // 清理并创建源目录
        deleteIfExists(Paths.get(SOURCE_DIR));
        deleteIfExists(Paths.get(TARGET_DIR));
        Files.createDirectories(Paths.get(SOURCE_DIR));
        Files.createDirectories(Paths.get(Paths.get(SOURCE_DIR), "subdir"));

        // 各种不规范命名
        Path[] messyFiles = {
            Paths.get(SOURCE_DIR, "大翔 的 照片.JPG"),        // 中文+空格
            Paths.get(SOURCE_DIR, "logo   final.png"),        // 多余空格
            Paths.get(SOURCE_DIR, "FEIXIANG-BANNER.PNG"),     // 大写扩展名
            Paths.get(SOURCE_DIR, "pic_2024_01_15"),           // 无扩展名
            Paths.get(SOURCE_DIR, "报表 -- 2024.xlsx"),        // 特殊字符
            Paths.get(SOURCE_DIR, "subdir", "Frank's Photo.jpg"), // 子目录 + 引号
            Paths.get(SOURCE_DIR, "subdir", "zhulu_resume.PDF"),  // 大写扩展名
            Paths.get(SOURCE_DIR, "subdir", "README.txt"),         // 正常命名
        };

        for (Path f : messyFiles) {
            Files.createDirectories(f.getParent());
            // 写入一些内容以创建文件
            Files.write(f, ("file: " + f.getFileName()).getBytes("UTF-8"),
                    StandardOpenOption.CREATE);
        }

        System.out.println("[白歌] 测试文件准备完成，共 " + messyFiles.length + " 个文件\n");
    }

    /**
     * 批量重命名：规范文件名
     * 规则：
     *  - 中文空格替换为下划线
     *  - 多个空格合并为一个下划线
     *  - 去除特殊字符（保留 中文/英文/数字/下划线/连字符/点）
     *  - 扩展名统一为小写
     */
    public static void batchRename(Path rootDir) throws IOException {
        System.out.println("========== 阶段一：批量重命名 ==========");

        try (Stream<Path> files = Files.walk(rootDir)) {
            List<Path> allFiles = files
                    .filter(Files::isRegularFile)
                    .collect(Collectors.toList());

            for (Path file : allFiles) {
                String oldName = file.getFileName().toString();
                String newName = normalizeFileName(oldName);

                if (!newName.equals(oldName)) {
                    Path newPath = file.resolveSibling(newName);
                    Files.move(file, newPath, StandardCopyOption.REPLACE_EXISTING);
                    renamedCount++;
                    System.out.printf("[小崔] 重命名: '%s' => '%s'%n", oldName, newName);
                } else {
                    skippedCount++;
                }
            }
        }
        System.out.println();
    }

    /**
     * 规范化文件名
     */
    private static String normalizeFileName(String fileName) {
        // 分离文件名和扩展名
        int dotIndex = fileName.lastIndexOf('.');
        String namePart, extPart;
        if (dotIndex > 0) {
            namePart = fileName.substring(0, dotIndex);
            extPart = "." + fileName.substring(dotIndex + 1).toLowerCase();
        } else {
            namePart = fileName;
            extPart = "";
        }

        // 去除特殊字符（保留中文、字母、数字、下划线、连字符）
        String cleaned = namePart.replaceAll("[^\\u4e00-\\u9fa5a-zA-Z0-9_\\-\\s]", "");
        // 多余空格合并为单个下划线
        cleaned = cleaned.replaceAll("\\s+", "_");
        // 多个下划线合并
        cleaned = cleaned.replaceAll("_+", "_");
        // 去除首尾下划线
        cleaned = cleaned.replaceAll("^_|_$", "");

        // 如果清理后为空，使用默认名
        if (cleaned.isEmpty()) {
            cleaned = "unnamed";
        }

        return cleaned + extPart;
    }

    /**
     * 按修改月份归档到目标目录
     */
    public static void archiveByMonth(Path srcDir, Path destDir) throws IOException {
        System.out.println("========== 阶段二：按时间归档 ==========");

        Files.createDirectories(destDir);

        try (Stream<Path> files = Files.walk(srcDir)) {
            files.filter(Files::isRegularFile).forEach(file -> {
                try {
                    BasicFileAttributes attrs =
                            Files.readAttributes(file, BasicFileAttributes.class);
                    // 获取修改时间的年月
                    FileTime modTime = attrs.lastModifiedTime();
                    String yearMonth = modTime.toString().substring(0, 7); // "2024-03"

                    // 目标子目录
                    Path monthDir = destDir.resolve(yearMonth);
                    Files.createDirectories(monthDir);

                    // 目标文件路径
                    Path destFile = monthDir.resolve(file.getFileName());
                    Files.copy(file, destFile, StandardCopyOption.REPLACE_EXISTING);
                    copiedCount++;
                    System.out.printf("[白歌] 归档: %s => %s%n",
                            file.getFileName(), destFile);

                } catch (IOException e) {
                    System.err.println("[小崔] 归档失败: " + file + " - " + e.getMessage());
                }
            });
        }
        System.out.println();
    }

    /**
     * 对比源目录和目标目录的内容
     */
    private static void compareDirectories() throws IOException {
        System.out.println("========== 阶段三：目录对比 ==========");

        System.out.println("[Frank] 源目录 (整理后):");
        try (Stream<Path> files = Files.walk(Paths.get(SOURCE_DIR))) {
            files.filter(Files::isRegularFile)
                 .forEach(f -> System.out.println("  " + f.getFileName()));
        }

        System.out.println("\n[Frank] 目标目录 (归档后):");
        try (Stream<Path> files = Files.walk(Paths.get(TARGET_DIR))) {
            files.filter(Files::isRegularFile)
                 .forEach(f -> System.out.println("  " + f));
        }
        System.out.println();
    }

    private static void printSummary() {
        System.out.println("========================================");
        System.out.println("   飞翔科技 批量文件处理报告");
        System.out.println("========================================");
        System.out.printf("  重命名: %d 个文件%n", renamedCount);
        System.out.printf("  归档:   %d 个文件%n", copiedCount);
        System.out.printf("  跳过:   %d 个文件 (名称已规范)%n", skippedCount);
        System.out.printf("  源目录: %s%n", SOURCE_DIR);
        System.out.printf("  目标目录: %s%n", TARGET_DIR);
        System.out.println("========================================");
    }

    private static void deleteIfExists(Path dir) throws IOException {
        if (Files.exists(dir)) {
            try (Stream<Path> files = Files.walk(dir)) {
                files.sorted(Comparator.reverseOrder()) // 先删文件再删目录
                     .forEach(f -> {
                         try { Files.deleteIfExists(f); }
                         catch (IOException e) { /* ignore */ }
                     });
            }
        }
    }
}

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

/**
 * 飞翔科技 - Path vs File 对比示例
 * 场景：对比 JDK 7 NIO.2 与传统 IO 的文件操作方式
 * 作者：大翔 & Frank
 */
public class PathVsFileComparison {

    public static void main(String[] args) throws IOException {
        System.out.println("========== 飞翔科技 Path vs File 对比 ==========\n");

        compare_CreateAndDelete();
        compare_ReadWrite();
        compare_ListFiles();
        compare_CopyAndMove();
        compare_FileAttributes();
    }

    /**
     * 对比1：创建和删除操作
     */
    private static void compare_CreateAndDelete() throws IOException {
        System.out.println("--- 创建与删除 ---");

        // ❌ 老式 File API
        File oldDir = new File("d:/feixiang/comparison/file_way");
        boolean created = oldDir.mkdirs();  // 返回boolean，失败时不知道原因
        System.out.println("[朱璐] File.mkdirs: " + created);
        File oldFile = new File(oldDir, "test.txt");
        oldFile.createNewFile();  // 返回boolean

        // ✅ NIO.2 Path API
        Path newDir = Paths.get("d:/feixiang/comparison/path_way");
        Path result = Files.createDirectories(newDir);  // 返回创建的路径
        System.out.println("[Frank] Files.createDirectories: " + result);
        Path newFile = newDir.resolve("test.txt");
        Files.createFile(newFile);  // 文件已存在抛 FileAlreadyExistsException

        // 删除清理
        Files.delete(newFile);       // 文件不存在抛异常
        Files.deleteIfExists(newFile); // 无异常版本
        oldFile.delete();
    }

    /**
     * 对比2：读写文件
     */
    private static void compare_ReadWrite() throws IOException {
        System.out.println("\n--- 文件读写 ---");

        Path file = Paths.get("d:/feixiang/comparison/readwrite.txt");
        Files.createDirectories(file.getParent());

        // ✅ NIO.2: 一行读取所有行
        Files.write(file, 
            java.util.Arrays.asList("飞翔科技", "Feixiang Technology", "2024"),
            StandardCharsets.UTF_8);

        List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
        System.out.println("[白歌] readAllLines: " + lines);

        // ✅ NIO.2: 一次性读取所有字节
        byte[] allBytes = Files.readAllBytes(file);
        System.out.println("[大翔] readAllBytes length: " + allBytes.length);

        // ✅ NIO.2: 使用 Stream 逐行处理（大文件友好）
        try (Stream<String> lineStream = Files.lines(file, StandardCharsets.UTF_8)) {
            long count = lineStream
                    .filter(l -> l.contains("飞翔"))
                    .count();
            System.out.println("[Frank] lines().filter 包含'飞翔'的行数: " + count);
        }

        // ✅ NIO.2: newBufferedReader / newBufferedWriter 与传统方式对比
        // 传统方式：
        //   BufferedReader br = new BufferedReader(new InputStreamReader(
        //       new FileInputStream("file"), "UTF-8"));
        // NIO.2方式（更简洁）:
        try (BufferedReader br = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
            String firstLine = br.readLine();
            System.out.println("[白歌] newBufferedReader 第一行: " + firstLine);
        }

        // 清理
        Files.deleteIfExists(file);
    }

    /**
     * 对比3：列出目录
     */
    private static void compare_ListFiles() throws IOException {
        System.out.println("\n--- 目录列表 ---");

        Path dir = Paths.get("d:/feixiang/comparison/list_test");
        Files.createDirectories(dir);
        Files.createFile(dir.resolve("a.txt"));
        Files.createFile(dir.resolve("b.txt"));
        Files.createFile(dir.resolve("c.log"));
        Files.createDirectory(dir.resolve("subdir"));

        // ❌ File: listFiles 返回 File[]，需要写循环
        File oldDir = dir.toFile();
        File[] files = oldDir.listFiles();
        if (files != null) {
            for (File f : files) {
                System.out.println("[朱璐] File.listFiles: " + f.getName());
            }
        }

        // ✅ NIO.2: Files.list 返回 Stream<Path>（try-with-resources保证关闭）
        System.out.println("--- 仅列出 .txt 文件 ---");
        try (Stream<Path> stream = Files.list(dir)) {
            stream.filter(p -> p.toString().endsWith(".txt"))
                  .forEach(p -> System.out.println(
                          "[Frank] Files.list.filter: " + p.getFileName()));
        }

        // ✅ NIO.2: Files.walk 返回 Stream（递归，限制深度）
        System.out.println("--- 递归遍历（深度2） ---");
        try (Stream<Path> stream = Files.walk(dir, 2)) {
            stream.forEach(p -> System.out.println(
                    "[大翔] Files.walk: " + p.getFileName()));
        }

        // 清理
        Files.walk(dir)
             .sorted(java.util.Comparator.reverseOrder())
             .forEach(p -> {
                 try { Files.deleteIfExists(p); }
                 catch (IOException e) { /* ignore */ }
             });
    }

    /**
     * 对比4：复制和移动
     */
    private static void compare_CopyAndMove() throws IOException {
        System.out.println("\n--- 复制与移动 ---");

        Path workDir = Paths.get("d:/feixiang/comparison/cmtest");
        Files.createDirectories(workDir);

        Path src = workDir.resolve("source.txt");
        Files.write(src, "飞翔科技源文件".getBytes(StandardCharsets.UTF_8));

        // ✅ NIO.2: Files.copy
        Path dest = workDir.resolve("copy_target.txt");
        Files.copy(src, dest, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("[白歌] Files.copy: " + Files.exists(dest));

        // ✅ NIO.2: Files.move (相当于重命名)
        Path moved = workDir.resolve("moved_target.txt");
        Files.move(dest, moved, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("[大翔] Files.move: copy_target.txt -> moved_target.txt, "
                + "原文件存在=" + Files.exists(dest));

        // ❌ File: renameTo 不可靠（跨文件系统可能失败、没有异常信息）
        File oldFile = new File(workDir.toFile(), "old.txt");
        oldFile.createNewFile();
        File newFile = new File(workDir.toFile(), "new.txt");
        boolean renamed = oldFile.renameTo(newFile);
        System.out.println("[朱璐] File.renameTo: " + renamed
                + " (无异常信息，失败也返回false)");

        // 清理
        Files.deleteIfExists(src);
        Files.deleteIfExists(moved);
        Files.deleteIfExists(newFile.toPath());
        Files.deleteIfExists(workDir);
    }

    /**
     * 对比5：文件属性
     */
    private static void compare_FileAttributes() throws IOException {
        System.out.println("\n--- 文件属性 ---");

        Path file = Paths.get("d:/feixiang/comparison/attr_test.txt");
        Files.createDirectories(file.getParent());
        Files.write(file, "test".getBytes(StandardCharsets.UTF_8));

        // ✅ NIO.2: 一次性读取所有基本属性
        BasicFileAttributes attrs = Files.readAttributes(file, BasicFileAttributes.class);
        System.out.println("[Frank] BasicFileAttributes:");
        System.out.println("  size: " + attrs.size());
        System.out.println("  isDirectory: " + attrs.isDirectory());
        System.out.println("  creationTime: " + attrs.creationTime());
        System.out.println("  lastModifiedTime: " + attrs.lastModifiedTime());

        // ✅ NIO.2: Files 直接提供的便捷方法
        long size = Files.size(file);
        boolean exists = Files.exists(file);
        System.out.println("[大翔] Files.size: " + size);
        System.out.println("[大翔] Files.exists: " + exists);

        // ❌ File: 每次属性查询是一个系统调用
        File oldFile = file.toFile();
        System.out.println("[朱璐] File.length: " + oldFile.length());
        System.out.println("[朱璐] File.exists: " + oldFile.exists());
        System.out.println("[朱璐] File.lastModified: " + oldFile.lastModified());

        Files.deleteIfExists(file);
        Files.deleteIfExists(file.getParent());
    }
}

// ❌ 错误：Stream 未关闭导致资源泄漏
Stream<Path> files = Files.walk(Paths.get("d:/feixiang"));
files.filter(Files::isRegularFile)
     .forEach(System.out::println);
// Stream 打开的文件描述符/目录句柄没有释放！

// ✅ 正确：使用 try-with-resources
try (Stream<Path> files = Files.walk(Paths.get("d:/feixiang"))) {
    files.filter(Files::isRegularFile)
         .forEach(System.out::println);
}  // 自动关闭 Stream，释放底层资源

// ❌ 错误：盲目使用 Files.delete()
Files.delete(Paths.get("d:/feixiang/may_not_exist.txt"));
// 文件不存在 → NoSuchFileException!
// 目录非空 → DirectoryNotEmptyException!

// ✅ 正确：先检查或使用 deleteIfExists
Path path = Paths.get("d:/feixiang/may_not_exist.txt");
Files.deleteIfExists(path);  // 文件不存在仅返回false，不抛异常

// ✅ 删除非空目录的正确方式
Path dir = Paths.get("d:/feixiang/non_empty_dir");
try (Stream<Path> files = Files.walk(dir)) {
    files.sorted(Comparator.reverseOrder())  // 深度优先，先删文件后删目录
         .forEach(p -> {
             try {
                 Files.delete(p);
             } catch (IOException e) {
                 throw new UncheckedIOException(e);
             }
         });
}

// ❌ 硬编码 Windows 路径分隔符
Path winPath = Paths.get("d:\\feixiang\\logs\\app.log");  // 仅Windows可用

// ❌ 硬编码 Unix 路径分隔符
Path unixPath = Paths.get("/opt/feixiang/logs/app.log");   // 仅Linux/Mac可用

// ✅ 使用可变参数或 File.separator
Path path1 = Paths.get("d:", "feixiang", "logs", "app.log");  // 跨平台
Path path2 = Paths.get(System.getProperty("user.dir"), "logs", "app.log");
Path path3 = FileSystems.getDefault().getPath("d:", "feixiang", "logs");

// 或者使用 resolve 拼接
Path base = Paths.get("d:/feixiang");
Path full = base.resolve("logs").resolve("app.log");

// ❌ 错误：2GB的日志文件用 readAllLines → OutOfMemoryError
List<String> lines = Files.readAllLines(Paths.get("d:/huge_server.log"));
for (String line : lines) {
    processLine(line);
}

// ✅ 方案1：使用 Files.lines() 返回 Stream（惰性读取）
try (Stream<String> lines = Files.lines(Paths.get("d:/huge_server.log"))) {
    lines.filter(l -> l.contains("ERROR"))
         .forEach(System.out::println);
}

// ✅ 方案2：使用 newBufferedReader 逐行读取
try (BufferedReader br = Files.newBufferedReader(
        Paths.get("d:/huge_server.log"), StandardCharsets.UTF_8)) {
    String line;
    while ((line = br.readLine()) != null) {
        processLine(line);
    }
}

Path path = Paths.get("d:/feixiang/logs/app.log");

// resolve: 在路径末尾追加 → d:/feixiang/logs/app.log/data
Path r1 = path.resolve("data");

// resolveSibling: 替换路径最后一段 → d:/feixiang/logs/error.log
Path r2 = path.resolveSibling("error.log");

// 常见错误：想拼接到目录层级，却用了 resolve
Path dir = Paths.get("d:/feixiang/logs");  // 这是一个目录
Path file = dir.resolve("app.log");         // d:/feixiang/logs/app.log ✅

Path filePath = Paths.get("d:/feixiang/logs/app.log");  // 这是一个文件路径
Path wrong = filePath.resolve("error.log");  // d:/feixiang/logs/app.log/error.log ❌
Path correct = filePath.resolveSibling("error.log");     // d:/feixiang/logs/error.log ✅

// ❌ 不推荐：readAllLines → OOM
// ❌ 不推荐：readAllBytes → OOM

// ✅ 最佳实践：Files.lines() 惰性读取 + Stream处理
try (Stream<String> lines = Files.lines(
        Paths.get("d:/huge.log"), StandardCharsets.UTF_8)) {
    // 统计ERROR行数而不加载全部到内存
    long errorCount = lines.filter(l -> l.contains("ERROR")).count();
    System.out.println("ERROR count: " + errorCount);
}

// ✅ 备选：Files.newBufferedReader 传统方式
try (BufferedReader br = Files.newBufferedReader(
        Paths.get("d:/huge.log"), StandardCharsets.UTF_8)) {
    String line;
    int lineNum = 0;
    while ((line = br.readLine()) != null) {
        if (lineNum++ % 100000 == 0) {
            System.out.println("Processing line " + lineNum);
        }
    }
}

// Files.list: 列出当前目录（非递归）
try (Stream<Path> entries = Files.list(Paths.get("."))) {
    entries.filter(Files::isRegularFile)
           .sorted(Comparator.comparingLong(p -> {
               try { return Files.size(p); }
               catch (IOException e) { return 0L; }
           }))
           .forEach(System.out::println);
}

// Files.find: 按条件搜索（递归）
try (Stream<Path> matches = Files.find(
        Paths.get("d:/feixiang"),
        5,  // 最大深度
        (path, attrs) -> attrs.isRegularFile()
                && path.toString().endsWith(".log")
                && attrs.size() > 1024)) {
    matches.forEach(System.out::println);
}

// Files.lines: 读取文件所有行作为 Stream
try (Stream<String> lines = Files.lines(
        Paths.get("d:/feixiang/data.csv"), StandardCharsets.UTF_8)) {
    List<String> headers = lines.skip(0).limit(1)
            .flatMap(line -> Stream.of(line.split(",")))
            .collect(Collectors.toList());
    System.out.println("CSV Headers: " + headers);
}