解密 `java.io.FileNotFoundException`：从路径到权限，Java文件操作不再“迷路”（小白指南）

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileNotFoundDemo {
    public static void main(String[] args) {
        // 尝试读取一个当前目录下不存在的文件
        File file = new File("a_non_existent_file.txt");
        FileInputStream fis = null;

        System.out.println("尝试读取文件: " + file.getAbsolutePath()); // 打印尝试访问的绝对路径

        try {
            fis = new FileInputStream(file);
            // 如果文件找到，这里可以进行读取操作
            System.out.println("文件找到，准备读取...");
            // int data;
            // while ((data = fis.read()) != -1) {
            //     System.out.print((char) data);
            // }
        } catch (FileNotFoundException e) {
            System.err.println("\n糟糕，文件没有找到！(FileNotFoundException)");
            System.err.println("异常信息: " + e.getMessage()); // 通常包含文件名和“系统找不到指定的文件”等提示
            // e.printStackTrace(System.err); // 打印完整的堆栈跟踪信息
        } catch (IOException e) {
            // 处理其他可能的IO异常
            System.err.println("\n发生其他IO异常!");
            e.printStackTrace(System.err);
        } finally {
            // 无论是否发生异常，都需要确保关闭流（如果流已成功打开）
            if (fis != null) {
                try {
                    fis.close();
                    System.out.println("\n文件流已关闭。");
                } catch (IOException e) {
                    System.err.println("\n关闭文件流时发生错误!");
                    e.printStackTrace(System.err);
                }
            }
        }
    }
}

尝试读取文件: C:\Your\Project\Path\a_non_existent_file.txt (具体路径取决于你的环境)

糟糕，文件没有找到！(FileNotFoundException)
异常信息: a_non_existent_file.txt (系统找不到指定的文件。)

// Windows (注意在Java字符串中，反斜杠'\'需要转义为'\\', 或者直接用斜杠'/')
File configFileWin = new File("C:\\Program Files\\MyApp\\config.ini");
File configFileWinAlternative = new File("C:/Program Files/MyApp/config.ini"); // Java推荐

// Linux/macOS
File configFileNix = new File("/etc/myapp/config.xml");

String currentWorkingDir = System.getProperty("user.dir");
System.out.println("当前工作目录 (CWD): " + currentWorkingDir);

File dataFile = new File("data/input.txt"); // 假设CWD下有data目录
System.out.println("尝试访问相对路径: " + dataFile.getAbsolutePath()); // 查看它解析成的绝对路径

File oldApiFile = new File("legacy/path/to/file.txt");
if (oldApiFile.exists()) {
    System.out.println("File exists: " + oldApiFile.getName());
}

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

public class NioPathDemo {
    public static void main(String[] args) {
        // 创建Path对象
        Path configFile = Paths.get("config", "app.properties"); // 相对路径
        Path logFile = Paths.get("C:", "var", "log", "app.log");    // 绝对路径

        System.out.println("Config file path: " + configFile.toAbsolutePath());
        System.out.println("Log file path: " + logFile);

        // 使用Files工具类检查文件
        if (Files.exists(configFile) && Files.isRegularFile(configFile)) {
            System.out.println(configFile.getFileName() + " 存在且是一个普通文件。");
            try (InputStream is = Files.newInputStream(configFile)) {
                // 读取文件内容
                System.out.println("可以读取 " + configFile.getFileName());
            } catch (IOException e) {
                System.err.println("读取文件 " + configFile.getFileName() + " 出错: " + e.getMessage());
            }
        } else {
            System.out.println(configFile.toAbsolutePath() + " 不存在或不是一个普通文件。");
        }
    }
}

File sensitiveFile = new File("/root/secret.txt"); // 假设普通用户无权访问
if (!sensitiveFile.canRead()) {
    System.err.println("警告: 程序可能没有读取 " + sensitiveFile.getAbsolutePath() + " 的权限。");
}

File myPath = new File("some_directory");
if (myPath.isDirectory()) {
    System.err.println(myPath.getAbsolutePath() + " 是一个目录，不能用FileInputStream打开。");
} else if (myPath.isFile()) {
    // 可以尝试打开
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class ResourceAccessDemo {

    public void loadResourceFromClasspathRoot(String resourceName) {
        System.out.println("\n尝试从类路径根加载资源: " + resourceName);
        // 使用当前类的类加载器
        ClassLoader classLoader = ResourceAccessDemo.class.getClassLoader();
        // 或者更通用: Thread.currentThread().getContextClassLoader();

        try (InputStream inputStream = classLoader.getResourceAsStream(resourceName)) {
            if (inputStream == null) {
                System.err.println("资源未找到: " + resourceName);
                // 这里可以抛出自定义异常或记录错误
                // throw new FileNotFoundException("Classpath resource not found: " + resourceName);
                return;
            }
            // 使用 try-with-resources 确保 InputStreamReader 和 BufferedReader 被关闭
            try (InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
                 BufferedReader reader = new BufferedReader(streamReader)) {

                String line;
                System.out.println("资源内容 (" + resourceName + "):");
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            }
        } catch (IOException e) {
            System.err.println("读取资源 " + resourceName + " 时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void loadResourceRelativeToClass(String resourceName) {
        System.out.println("\n尝试从类相对路径加载资源: " + resourceName);
        // 资源与 ResourceAccessDemo.class 在同一包下，或通过相对路径指定
        try (InputStream inputStream = ResourceAccessDemo.class.getResourceAsStream(resourceName)) {
            if (inputStream == null) {
                System.err.println("类相对资源未找到: " + resourceName);
                return;
            }
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                String line;
                System.out.println("资源内容 (" + resourceName + "):");
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            }
        } catch (IOException e) {
            System.err.println("读取类相对资源 " + resourceName + " 时发生错误: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        ResourceAccessDemo demo = new ResourceAccessDemo();

        // 假设你的 src/main/resources/ 目录下有:
        // 1. my_app_config.properties
        // 2. com/example/data/internal_data.txt (注意包结构)

        demo.loadResourceFromClasspathRoot("my_app_config.properties");
        demo.loadResourceFromClasspathRoot("com/example/data/internal_data.txt");

        // 如果 ResourceAccessDemo 在 com.mypackage 包下，并且想加载同包下的 local_resource.txt
        // demo.loadResourceRelativeToClass("local_resource.txt");
        // 如果想通过绝对类路径方式加载 (等同于 ClassLoader 的方式)
        // demo.loadResourceRelativeToClass("/my_app_config.properties");
    }
}

Path filePath = Paths.get("mydata", "input.dat");
if (Files.exists(filePath)) {
    if (Files.isRegularFile(filePath)) {
        if (Files.isReadable(filePath)) {
            try (InputStream is = Files.newInputStream(filePath)) {
                System.out.println("成功打开文件 " + filePath.getFileName() + " 进行读取。");
                // ... 进行读取操作 ...
            } catch (IOException e) {
                System.err.println("读取文件时发生IO错误: " + e.getMessage());
            }
        } else {
            System.err.println("文件不可读: " + filePath.toAbsolutePath());
        }
    } else {
        System.err.println("路径不是一个普通文件: " + filePath.toAbsolutePath());
    }
} else {
    System.err.println("文件或目录不存在: " + filePath.toAbsolutePath());
    // 可以尝试创建文件或目录 (如果逻辑需要)
    // try {
    //     Files.createDirectories(filePath.getParent()); //确保父目录存在
    //     Files.createFile(filePath); //尝试创建文件
    //     System.out.println("文件已创建: " + filePath.toAbsolutePath());
    // } catch (IOException createEx) {
    //    System.err.println("创建文件失败: " + createEx.getMessage());
    // }
}

try (FileInputStream fis = new FileInputStream("config.txt");
     InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
     BufferedReader reader = new BufferedReader(isr)) {
    // ... 读取操作 ...
} catch (FileNotFoundException e) {
    System.err.println("配置文件未找到: " + new File("config.txt").getAbsolutePath());
} catch (IOException e) {
    System.err.println("读取配置文件时发生IO错误: " + e.getMessage());
}

String userHome = System.getProperty("user.home");
Path userDocs = Paths.get(userHome, "Documents", "MyAppConfig.xml");
System.out.println("用户配置文件路径: " + userDocs);

File configFile = new File("conf/app-settings.ini");
try (FileInputStream fis = new FileInputStream(configFile)) {
    // ... load settings ...
} catch (FileNotFoundException e) {
    // 使用日志框架记录错误，例如 SLF4J + Logback
    // logger.error("无法找到配置文件: {}", configFile.getAbsolutePath(), e);
    System.err.println("严重错误：无法加载核心配置文件 '" + configFile.getAbsolutePath() + "'。程序可能无法正常运行。");
    // 可以在这里决定是退出程序还是使用默认设置
} catch (IOException e) {
    // logger.error("读取配置文件 {} 时发生I/O错误", configFile.getAbsolutePath(), e);
    System.err.println("读取配置文件时发生错误。请检查文件格式和权限。");
}