NIO与Files工具类

// Paths.get() 创建 Path（JDK 7/8 唯一方式）
Path p1 = Paths.get("C:/feixiang/data/employees.csv");
Path p2 = Paths.get("C:", "feixiang", "data", "employees.csv");  // 可变参数
Path p3 = Paths.get("C:/feixiang", "data/employees.csv");  // 自动拼接

// File → Path（桥接旧API）
File oldFile = new File("C:/data");
Path path = oldFile.toPath();

// Path → File（桥接回旧API）
File backToFile = path.toFile();

// 传统方式：遍历目录
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for (Path entry : stream) {
        System.out.println(entry.getFileName());
    }
}

// 带过滤的遍历
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, "*.{java,class}")) {
    // 只匹配 .java 和 .class 文件
}

// SimpleFileVisitor 提供了默认空实现，只需覆盖需要的方法
Files.walkFileTree(startDir, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        // 处理每个文件
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        // 进入目录前
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
        // 文件访问失败时
        return FileVisitResult.CONTINUE;
    }
});

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

/**
 * 飞翔科技 - 配置管理器（NIO.2版）
 * 使用 Files 工具类实现配置文件的读写、备份和搜索
 */
public class ConfigManagerNIO {
    private static final Path CONFIG_DIR = Paths.get("C:/feixiang/config");
    private static final Path CONFIG_FILE = CONFIG_DIR.resolve("server.conf");
    private static final Path BACKUP_DIR = CONFIG_DIR.resolve("backup");

    public static void main(String[] args) {
        System.out.println("=== 飞翔科技配置管理器（NIO.2版）===\n");

        // 1. 确保目录存在
        initDirectories();

        // 2. 写入配置
        writeConfig();

        // 3. 读取配置
        readConfig();

        // 4. 搜索配置项
        searchConfig("host");

        // 5. 备份配置
        backupConfig();

        // 6. 列出所有备份
        listBackups();

        // 7. 流式搜索所有配置文件中的关键字
        searchAllConfigs("admin");
    }

    /** 初始化目录结构 */
    private static void initDirectories() {
        try {
            if (!Files.exists(CONFIG_DIR)) {
                Files.createDirectories(CONFIG_DIR);
                System.out.println("[初始化] 创建配置目录：" + CONFIG_DIR);
            }
            if (!Files.exists(BACKUP_DIR)) {
                Files.createDirectories(BACKUP_DIR);
                System.out.println("[初始化] 创建备份目录：" + BACKUP_DIR);
            }
        } catch (IOException e) {
            throw new RuntimeException("目录初始化失败", e);
        }
    }

    /** 写入配置文件 */
    private static void writeConfig() {
        try {
            List<String> lines = List.of(
                "# 飞翔科技服务器配置",
                "# 生成时间：" + java.time.LocalDateTime.now(),
                "db.host=192.168.1.100",
                "db.port=3306",
                "db.name=feixiang",
                "admin.name=大翔",
                "admin.email=daxiang@feixiang.com",
                "log.level=INFO",
                "log.path=/var/log/feixiang/"
            );

            // 一行代码写入所有行（指定UTF-8编码）
            Files.write(CONFIG_FILE, lines, StandardCharsets.UTF_8);

            long size = Files.size(CONFIG_FILE);
            System.out.println("[写入] 配置文件已保存：" + CONFIG_FILE);
            System.out.println("[写入] 文件大小：" + size + " bytes");

        } catch (IOException e) {
            System.err.println("配置写入失败：" + e.getMessage());
        }
    }

    /** 读取配置文件 */
    private static void readConfig() {
        try {
            System.out.println("\n[读取] 配置文件内容：");
            System.out.println("--------------------------------");

            // JDK 8 新增：lines() 返回 Stream，惰性读取（大文件也安全）
            try (Stream<String> lines = Files.lines(CONFIG_FILE, StandardCharsets.UTF_8)) {
                lines.forEach(line -> System.out.println("  " + line));
            }

        } catch (IOException e) {
            System.err.println("配置读取失败：" + e.getMessage());
        }
    }

    /** 搜索包含关键字的配置行 */
    private static void searchConfig(String keyword) {
        try {
            System.out.println("\n[搜索] 包含 \"" + keyword + "\" 的配置项：");

            try (Stream<String> lines = Files.lines(CONFIG_FILE, StandardCharsets.UTF_8)) {
                List<String> results = lines
                    .filter(line -> line.contains(keyword))
                    .collect(Collectors.toList());

                if (results.isEmpty()) {
                    System.out.println("  （无匹配项）");
                } else {
                    results.forEach(line -> System.out.println("  " + line));
                }
            }

        } catch (IOException e) {
            System.err.println("搜索失败：" + e.getMessage());
        }
    }

    /** 备份配置文件 */
    private static void backupConfig() {
        try {
            String timestamp = java.time.LocalDateTime.now()
                .format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
            Path backupFile = BACKUP_DIR.resolve("server_" + timestamp + ".conf");

            Files.copy(CONFIG_FILE, backupFile, StandardCopyOption.REPLACE_EXISTING);

            System.out.println("\n[备份] 已备份到：" + backupFile.getFileName());

        } catch (IOException e) {
            System.err.println("备份失败：" + e.getMessage());
        }
    }

    /** 列出所有备份文件 */
    private static void listBackups() {
        try {
            System.out.println("\n[备份列表] " + BACKUP_DIR);

            try (Stream<Path> files = Files.list(BACKUP_DIR)) {
                files
                    .sorted((a, b) -> {
                        try {
                            return Files.getLastModifiedTime(b).compareTo(
                                Files.getLastModifiedTime(a));
                        } catch (IOException e) {
                            return 0;
                        }
                    })
                    .forEach(p -> {
                        try {
                            System.out.printf("  %-35s  %d bytes%n",
                                p.getFileName(), Files.size(p));
                        } catch (IOException ignored) {}
                    });
            }

        } catch (IOException e) {
            System.err.println("列出备份失败：" + e.getMessage());
        }
    }

    /** 流式搜索所有配置文件 */
    private static void searchAllConfigs(String keyword) {
        try {
            System.out.println("\n[全局搜索] 在所有配置文件中搜索 \"" + keyword + "\"：");

            Files.walk(CONFIG_DIR, 1)  // 只遍历配置目录自身及其直接子文件
                .filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".conf"))
                .forEach(p -> {
                    try (Stream<String> lines = Files.lines(p, StandardCharsets.UTF_8)) {
                        lines
                            .filter(line -> line.contains(keyword))
                            .forEach(line ->
                                System.out.printf("  %-30s | %s%n",
                                    p.getFileName(), line));
                    } catch (IOException ignored) {}
                });

        } catch (IOException e) {
            System.err.println("全局搜索失败：" + e.getMessage());
        }
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.util.concurrent.TimeUnit;

/**
 * 飞翔科技 - 日志目录监控工具
 * 使用 WatchService 监控文件创建、修改、删除事件
 */
public class LogDirectoryWatcher {
    private final Path watchDir;
    private final WatchService watchService;
    private volatile boolean running = true;

    public LogDirectoryWatcher(String dirPath) throws IOException {
        this.watchDir = Paths.get(dirPath);

        // 确保目录存在
        if (!Files.exists(watchDir)) {
            Files.createDirectories(watchDir);
        }

        // 创建 WatchService 并注册目录
        this.watchService = FileSystems.getDefault().newWatchService();
        watchDir.register(watchService,
            StandardWatchEventKinds.ENTRY_CREATE,   // 文件创建
            StandardWatchEventKinds.ENTRY_MODIFY,   // 文件修改
            StandardWatchEventKinds.ENTRY_DELETE    // 文件删除
        );

        System.out.println("[监控] 开始监控目录：" + watchDir.toAbsolutePath());
    }

    /** 启动监控（阻塞式） */
    public void start() {
        System.out.println("[监控] 按 Ctrl+C 停止监控...\n");

        while (running) {
            WatchKey key;
            try {
                // take() 阻塞等待事件（如果改用 poll(5, TimeUnit.SECONDS) 可超时返回）
                key = watchService.take();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (ClosedWatchServiceException e) {
                break;
            }

            for (WatchEvent<?> event : key.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();

                // OVERFLOW：事件丢失（缓冲区溢出，需全量重新扫描）
                if (kind == StandardWatchEventKinds.OVERFLOW) {
                    System.out.println("[警告] 事件丢失！可能有文件变化未被检测到");
                    continue;
                }

                // 获取变化的文件名
                @SuppressWarnings("unchecked")
                WatchEvent<Path> ev = (WatchEvent<Path>) event;
                Path filename = ev.context();

                // 事件类型中文描述
                String eventType = getEventDescription(kind);
                System.out.printf("[%s] %s - %s%n",
                    java.time.LocalTime.now().toString().substring(0, 8),
                    eventType, filename);

                // 实际项目中在此处触发日志处理逻辑
            }

            // ⚡ 关键：reset() 重新注册，返回 false 表示目录不可再访问
            if (!key.reset()) {
                System.err.println("[错误] 目录不再可访问，停止监控：" + watchDir);
                break;
            }
        }
    }

    /** 停止监控 */
    public void stop() {
        running = false;
        try {
            watchService.close();
        } catch (IOException e) {
            System.err.println("关闭 WatchService 失败");
        }
        System.out.println("\n[监控] 已停止");
    }

    private String getEventDescription(WatchEvent.Kind<?> kind) {
        if (kind == StandardWatchEventKinds.ENTRY_CREATE)  return "创建";
        if (kind == StandardWatchEventKinds.ENTRY_MODIFY)  return "修改";
        if (kind == StandardWatchEventKinds.ENTRY_DELETE)  return "删除";
        return "未知";
    }

    /**
     * 演示主方法
     * 运行本程序后，可以手动在该目录下创建/修改/删除文件来观察输出
     */
    public static void main(String[] args) throws Exception {
        LogDirectoryWatcher watcher = new LogDirectoryWatcher("C:/feixiang/logs/watch");

        // 启动一个线程模拟文件操作
        Thread simulator = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);

                // 模拟创建日志文件
                Path newLog = Paths.get("C:/feixiang/logs/watch/access_20250115.log");
                Files.write(newLog, "192.168.1.100 - admin [15/Jan/2025:15:30:00]".getBytes());
                System.out.println("  [模拟] 创建了日志文件");

                TimeUnit.SECONDS.sleep(1);

                // 模拟修改日志文件
                Files.write(newLog, "新日志行".getBytes(), StandardOpenOption.APPEND);
                System.out.println("  [模拟] 修改了日志文件");

                TimeUnit.SECONDS.sleep(1);

                // 模拟删除日志文件
                Files.delete(newLog);
                System.out.println("  [模拟] 删除了日志文件");

                TimeUnit.SECONDS.sleep(2);
                watcher.stop();

            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        simulator.setDaemon(true);
        simulator.start();

        watcher.start();
    }
}

// 传统方式：读取全部 → 内存爆炸
List<String> allLines = Files.readAllLines(hugeFile, UTF_8);  // 可能OOM

// JDK 8 流式：惰性读取，只处理前5条ERROR行
try (Stream<String> lines = Files.lines(hugeFile, UTF_8)) {
    lines.filter(line -> line.contains("ERROR"))
         .limit(5)
         .forEach(System.out::println);
}
// 内存中同时只保留少数几行

// ❌ 错误：1GB日志文件一次性加载到内存 → OutOfMemoryError
List<String> lines = Files.readAllLines(
    Paths.get("huge_server.log"), StandardCharsets.UTF_8);

// ✅ 正确：流式处理，惰性加载
try (Stream<String> lines = Files.lines(Paths.get("huge_server.log"), UTF_8)) {
    lines.filter(l -> l.contains("ERROR"))
         .forEach(System.out::println);
}

// ❌ 错误：文件不存在时抛出 NoSuchFileException
Files.delete(Paths.get("temp.txt"));
// 异常：java.nio.file.NoSuchFileException: temp.txt

// ✅ 正确：使用 deleteIfExists，不存在时静默返回 false
boolean deleted = Files.deleteIfExists(Paths.get("temp.txt"));
// deleted == false 表示文件本来就不存在，不是错误

// ❌ 错误：BufferedWriter 未关闭，缓冲区数据丢失
BufferedWriter writer = Files.newBufferedWriter(Paths.get("data.txt"), UTF_8);
writer.write("重要数据");
// 没有 close() —— 数据可能不完整！

// ✅ 正确：try-with-resources
try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("data.txt"), UTF_8)) {
    writer.write("重要数据");
}

// ❌ 错误：处理完事件未 reset，后续事件收不到
WatchKey key = watchService.take();
for (WatchEvent<?> event : key.pollEvents()) {
    System.out.println("文件变化：" + event.context());
}
// 没有 key.reset() → 该key失效，目录不再被监听！

// ✅ 正确：必须在处理完事件后调用 reset()
WatchKey key = watchService.take();
for (WatchEvent<?> event : key.pollEvents()) {
    System.out.println("文件变化：" + event.context());
}
boolean valid = key.reset();  // 重新注册到 WatchService
if (!valid) {
    System.err.println("目录不可访问，退出监控");
}