📜 摘要 (Abstract)java.io.FileNotFoundException 是Java程序在尝试访问一个文件，但因各种原因（如文件确实不存在、路径指定错误、权限不足，或试图以文件方式访问打包在JAR/WAR内的资源）未能成功时抛出的一个受检异常 (Checked Exception)。这个异常在进行文件读写操作时非常普遍，尤其是对于初学者而言，理解和正确处理文件路径、区分文件系统路径与类路径资源是常见的痛点。本文将从“小白”视角出发，详细阐述此异常发生的核心原因，深入探讨绝对路径与相对路径的区别与使用，介绍Java中处理文件路径的最佳实践（包括传统的 File 类和现代的NIO.2 Path API），并重点讲解如何正确访问打包在应用程序（如JAR或WAR包）中的资源文件。通过具体的Java代码示例和清晰的排错思路，本指南旨在帮助你彻底理解并有效避免和解决 FileNotFoundException。
🚀 引言 (Introduction)你好，我是默语。在Java编程中，与文件系统打交道是家常便饭，无论是读取配置文件、写入日志，还是处理用户上传的数据。然而，就在我们满怀期待地准备打开或创建一个文件时，一个名为 java.io.FileNotFoundException 的异常却可能不期而至，它冷静地告诉你：“抱歉，你要找的那个文件，我没找到。”
对于初学者来说，这无疑是一个打击。明明感觉文件就在那里，或者路径写得“应该”没错，为什么程序就是找不到呢？这个异常背后，其实隐藏着对文件路径、程序运行环境、文件权限以及Java资源加载机制的理解。
FileNotFoundException 是 IOException 的一个子类，它是一个受检异常。这意味着Java编译器会强制你在代码中处理它——要么使用 try-catch 语句捕获，要么在方法签名中通过 throws 关键字声明抛出。它通常在以下情况被抛出：
尝试打开一个不存在的文件进行读取。尝试打开一个路径指向的是目录而非普通文件进行读取。尝试创建一个新文件用于写入，但因为某些原因（如父目录不存在且无法创建，或没有写入权限导致无法创建文件句柄）无法进行。本篇博客的目标，就是为你这位“小白”朋友，详细拆解 FileNotFoundException 的各种“套路”，让你能够清晰地理解文件路径的“游戏规则”，学会如何在不同场景下正确地定位和访问文件，最终让文件操作不再成为你Java学习路上的“绊脚石”。
博主 默语带您 Go to New World.
✍ 个人主页—— 默语 的博客👦🏻 优秀内容
《java 面试题大全》
《java 专栏》
《idea技术专区》
《spring boot 技术专区》
《MyBatis从入门到精通》
《23种设计模式》
《经典算法学习》
《spring 学习》
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭
🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄之助。苟未尽善尽美，敬请批评指正，以资改进。！💻⌨
解密 java.io.FileNotFoundException：从路径到权限，Java文件操作不再“迷路”（小白指南）🛠️ 正文：攻克文件找不到的难题第一部分：FileNotFoundException 初识 —— “文件去哪儿了？”让我们先通过一个简单的Java代码示例，看看这个异常是如何“现身”的。
代码语言：javascript复制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);
}
}
}
}
}当你运行这段代码时，如果你的程序运行目录下确实没有 a_non_existent_file.txt 这个文件，你就会在控制台看到类似这样的错误输出：
代码语言：javascript复制尝试读取文件: C:\Your\Project\Path\a_non_existent_file.txt (具体路径取决于你的环境)
糟糕，文件没有找到！(FileNotFoundException)
异常信息: a_non_existent_file.txt (系统找不到指定的文件。)异常信息 e.getMessage() 通常会告诉你哪个文件路径出了问题。e.printStackTrace() 则会提供更详细的调用堆栈，帮助你定位到代码中触发异常的具体位置。
第二部分：拨开迷雾 —— 文件路径的奥秘理解文件路径是解决 FileNotFoundException 的核心。路径告诉程序去哪里寻找文件。
绝对路径 (Absolute Path): 清晰无误的“门牌号”
定义：绝对路径是一个从文件系统的根目录开始，到目标文件或目录的完整路径。它提供了文件的确切位置，不依赖于当前程序运行在哪个目录下。
示例：
Windows: C:\Users\YourName\Documents\MyProject\src\config.propertiesLinux/macOS: /home/yourname/projects/my_app/config/settings.xml优点：路径唯一确定，不会有歧义。
缺点：硬编码到程序中会降低可移植性。如果你的程序换到另一台机器上，或者文件被移动到不同位置，硬编码的绝对路径就会失效。
Java代码示例：
代码语言：javascript复制// 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");Java的 File 类和NIO.2 API在内部可以很好地处理用 / 作为路径分隔符的情况，即使在Windows上也是如此，所以推荐在Java代码中统一使用 /。
相对路径 (Relative Path): “相对于我，它在哪？”
定义：相对路径是相对于当前工作目录 (Current Working Directory, CWD) 的路径。CWD是JVM启动时程序所在的目录。
示例：
data/input.txt (表示CWD下的 data 子目录中的 input.txt)../logs/app.log (表示CWD的上一级目录下的 logs 子目录中的 app.log)my_file.txt (表示CWD下的 my_file.txt)优点：更具可移植性。只要你的文件结构相对于应用程序的根目录保持不变，程序就可以在不同环境下运行。
缺点：CWD可能会变，这取决于程序是如何启动的。对于初学者来说，判断CWD在哪里有时会比较困惑。
如何确定当前工作目录？
代码语言：javascript复制String currentWorkingDir = System.getProperty("user.dir");
System.out.println("当前工作目录 (CWD): " + currentWorkingDir);Java代码示例：
代码语言：javascript复制File dataFile = new File("data/input.txt"); // 假设CWD下有data目录
System.out.println("尝试访问相对路径: " + dataFile.getAbsolutePath()); // 查看它解析成的绝对路径路径分隔符 (Path Separators): 跨平台的“小麻烦”
Windows 使用反斜杠 \ 作为路径分隔符。Linux、macOS 和其他类UNIX系统使用斜杠 / 作为路径分隔符。为了编写跨平台的Java代码，应避免硬编码特定操作系统的分隔符。Java提供的解决方案： File.separator (字符串常量, 如 “\” 或 “/”)File.separatorChar (字符常量, 如 '\' 或 '/')最佳实践1：如前所述，在Java字符串中直接使用 / 通常是最简单且跨平台的方式，Java的I/O类会妥善处理。最佳实践2 (Java 7+)：使用NIO.2的 Paths.get() 方法构建路径，它会自动处理平台相关的分隔符。java.io.File 类 vs. java.nio.file.Path 接口 (NIO.2): 现代文件操作
java.io.File：这是Java早期提供的文件和目录路径的抽象表示。它提供了如创建、删除、重命名文件、判断文件属性（是否存在、是否是目录等）等基本操作。
代码语言：javascript复制File oldApiFile = new File("legacy/path/to/file.txt");
if (oldApiFile.exists()) {
System.out.println("File exists: " + oldApiFile.getName());
}java.nio.file.Path 和 java.nio.file.Files (Java 7+ 新I/O，NIO.2)：
Path 接口是现代的、更强大和灵活的文件路径表示。Paths 工具类（注意末尾有s）提供了静态工厂方法 get() 来创建 Path 对象。Files 工具类（注意末尾有s）提供了大量用于操作文件和目录的静态方法（如读写、复制、移动、检查属性等），通常比旧的 File API 更高效且能提供更详细的错误信息。 代码语言：javascript复制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() + " 不存在或不是一个普通文件。");
}
}
}对于新项目，强烈推荐使用NIO.2的 Path 和 Files API。
第三部分：FileNotFoundException 常见“病因”与诊断现在我们来具体分析哪些情况会导致这个异常。
文件确实不存在 (File Truly Does Not Exist):
这是最直接的原因。你指定的路径下，那个文件名的文件就是没有。诊断： 仔细检查文件名和扩展名是否拼写正确（包括大小写，在Linux/macOS这类大小写敏感的系统上尤其重要）。手动去操作系统对应的路径下查看文件是否存在。在代码中打印出尝试访问的文件的绝对路径 (file.getAbsolutePath() 或 path.toAbsolutePath().toString())，然后用这个绝对路径去文件系统中核实。路径错误 (Incorrect Path):
a. 绝对路径硬编码错误： 你在代码里写死的绝对路径在当前环境下无效（比如从开发机复制到服务器，路径变了）。b. 相对路径的“当前工作目录”不符合预期： 在IDE中运行：IntelliJ IDEA, Eclipse等IDE的默认CWD通常是你项目的根目录。所以 new File("src/main/resources/config.txt") 可能会工作。通过 java -jar myapp.jar 运行：CWD是你执行 java -jar 命令时所在的目录。如果你的JAR包希望从其自身旁边读取一个 config 文件夹下的文件，你应该相对于JAR包的位置来组织文件，或者使用更可靠的方式定位资源（见后文）。Web应用 (WAR包部署到Tomcat等服务器)：对于Web应用，使用 new File("relative_path") 时，相对路径通常是相对于Servlet容器（如Tomcat）的启动目录（例如 tomcat/bin 目录），而不是你的Web应用部署后的根目录（如 tomcat/webapps/myapp）。这是一个非常非常常见的坑！直接使用 new File() 访问Web应用内的资源通常是错误的。诊断：始终打印出文件对象解析后的绝对路径，看它是否指向你期望的位置。权限不足 (Insufficient Permissions):
你的Java程序运行所使用的用户账户，可能没有读取指定文件（或其所在目录）的权限。
诊断：
在操作系统层面检查文件和目录的权限设置。尝试用运行Java程序的同一个用户账户手动访问该文件，看是否能成功。在Java代码中，可以在尝试打开文件前使用 file.canRead() 或 Files.isReadable(path) 进行检查（但这只是一个提示，真正的权限检查发生在尝试打开文件时）。 代码语言：javascript复制File sensitiveFile = new File("/root/secret.txt"); // 假设普通用户无权访问
if (!sensitiveFile.canRead()) {
System.err.println("警告: 程序可能没有读取 " + sensitiveFile.getAbsolutePath() + " 的权限。");
}目标是目录而非文件 (Target is a Directory, Not a File):
如果你用 FileInputStream（或其他期望读取文件内容的流）去尝试打开一个目录，通常会得到 FileNotFoundException (在某些系统或Java版本上，错误信息可能提示它是目录)。
诊断：在打开文件前，使用 file.isFile() 或 Files.isRegularFile(path) 判断路径是否指向一个普通文件。
代码语言：javascript复制File myPath = new File("some_directory");
if (myPath.isDirectory()) {
System.err.println(myPath.getAbsolutePath() + " 是一个目录，不能用FileInputStream打开。");
} else if (myPath.isFile()) {
// 可以尝试打开
}文件正在被其他进程占用/锁定 (OS dependent):
在某些操作系统上（尤其是Windows），如果一个文件被某个程序以独占方式打开，其他程序尝试以不兼容的方式访问它时，可能会导致类似“文件找不到”或“访问被拒绝”的错误，有时也可能表现为 FileNotFoundException。诊断：这种情况比较复杂，通常需要检查是否有其他程序正在使用该文件。访问JAR包/WAR包内的资源问题 (The Big One! Accessing Resources Inside JAR/WAR):
核心陷阱：当你的Java应用程序被打包成一个JAR文件（或者Web应用被打包成WAR文件）后，里面的资源文件（如配置文件、图片、模板等，通常放在 src/main/resources 目录下）就不再是文件系统中的独立文件了。它们被压缩在归档文件中。因此，你绝对不能使用 new File("path/to/resource_in_jar.txt") 或 new FileInputStream("path/to/resource_in_jar.txt") 这样的方式去访问它们，因为文件系统中并不存在这样的独立路径。这样做几乎肯定会导致 FileNotFoundException。
正确解决方案：使用类加载器 (ClassLoader) 的 getResourceAsStream() 方法。
ClassLoader 提供了一种与物理文件系统解耦的方式来访问类路径下的资源。
InputStream getResourceAsStream(String name): name 参数是一个相对于类路径根目录的路径。如果资源位于 src/main/resources/config/app.properties，那么 name 应该是 config/app.properties (不需要开头的 /)。如果资源直接在 src/main/resources/ 下，如 log4j2.xml，那么 name 就是 log4j2.xml。这个方法返回一个 InputStream，你可以用它来读取资源内容。如果找不到资源，它会返回 null (不会直接抛 FileNotFoundException，但如果你用返回的 null去创建 InputStreamReader 等就会 NullPointerException)。获取 ClassLoader 的几种方式： MyClass.class.getClassLoader(): 获取加载 MyClass 这个类的类加载器。Thread.currentThread().getContextClassLoader(): 获取当前线程的上下文类加载器（在某些复杂应用或框架中更推荐）。Class.getResourceAsStream(String name) 也是一个常用方法： 如果 name 以 / 开头，则行为与 ClassLoader.getResourceAsStream() 类似，从类路径根开始查找。例如 MyClass.class.getResourceAsStream("/config/app.properties")。如果 name 不以 / 开头，则它是相对于当前类的包路径的。例如，如果 MyClass 在 com.example 包下，MyClass.class.getResourceAsStream("my_resource.txt") 会在 com/example/ 目录下寻找 my_resource.txt。Java代码示例 (正确访问JAR/WAR内资源):
代码语言：javascript复制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");
}
}关键点：确保你的资源文件（如 *.properties, *.xml, *.txt, 图片等）放在项目的 src/main/resources 目录下（如果是Maven/Gradle项目）。构建工具会自动将这些资源复制到输出目录（如 target/classes）的根，或者打包到JAR/WAR的根。然后你就可以用相对于类路径根的路径（如 config/settings.xml）来加载它们了。
第四部分：“对症下药”——预防与处理 FileNotFoundException编码时的防御性措施 (Defensive Measures During Coding):
a. 操作前检查文件状态 (Java NIO.2 Files API 优先)：
代码语言：javascript复制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());
// }
}b. 使用 try-with-resources 语句 (Java 7+)：
这能确保实现了 AutoCloseable 接口的资源（如 InputStream, OutputStream, Reader, Writer 等）在 try 块执行完毕后（无论正常结束还是发生异常）被自动关闭。这本身不预防 FileNotFoundException，但它是健壮I/O操作的基石。
代码语言：javascript复制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());
}构建可靠的文件路径:
优先使用 Paths.get() 来构建 Path 对象，它能更好地处理平台差异。
避免硬编码绝对路径。如果必须使用，考虑将其做成可配置项（例如从配置文件读取，或通过环境变量设置）。
对于需要与应用程序一起分发的文件，考虑将它们作为类路径资源打包，而不是依赖外部文件系统路径。
如果需要访问用户特定的目录（如用户主目录、文档目录），使用 System.getProperty("user.home") 等系统属性来构造基础路径。
代码语言：javascript复制String userHome = System.getProperty("user.home");
Path userDocs = Paths.get(userHome, "Documents", "MyAppConfig.xml");
System.out.println("用户配置文件路径: " + userDocs);正确处理程序内部资源（再次强调）：
始终使用 YourClass.class.getResourceAsStream() 或 YourClass.class.getClassLoader().getResourceAsStream() 来加载打包在JAR/WAR内部的资源文件。不要用 new File()。
清晰的错误处理与日志记录：
当捕获到 FileNotFoundException 时：
记录详细的错误信息：包括尝试访问的文件的绝对路径。这对于事后排查问题至关重要。向用户提供友好的错误提示，而不是直接暴露原始的异常信息。考虑是否需要进行重试、使用备用文件，或者优雅地失败。代码语言：javascript复制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("读取配置文件时发生错误。请检查文件格式和权限。");
}理解并适配部署环境：
你的Java程序最终会部署到哪里？是作为独立的JAR运行，还是作为WAR包部署到Web服务器，或者是Docker容器里？不同环境下的当前工作目录、文件系统结构、权限都可能不同。在开发时就要考虑到这些差异，编写具有良好适应性的文件访问代码。✨ 总结 (Summary)java.io.FileNotFoundException 是Java I/O编程中一个基础且不可避免的异常。攻克它的关键在于真正理解文件路径的解析方式、当前工作目录的概念，以及区分普通文件系统访问和类路径资源访问。
核心要点回顾：
路径是王道： 区分绝对路径和相对路径，理解相对路径依赖于“当前工作目录”。推荐使用 /作为路径分隔符或NIO.2的 Paths.get()。在捕获异常时，打印文件的绝对路径以帮助调试。文件存在性和权限： 操作文件前，使用 Files.exists(), Files.isRegularFile(), Files.isReadable() 等方法进行检查。确保程序运行用户具有足够的操作系统权限。JAR/WAR 内资源访问的“唯一真理”： 永远不要用 new File() 访问打包在JAR/WAR内的资源。必须使用 ClassLoader.getResourceAsStream() 或 Class.getResourceAsStream()。健壮的I/O操作： 始终使用 try-with-resources 确保流被正确关闭。提供清晰、有用的错误日志和用户提示。当你能够熟练运用这些知识点，并养成良好的文件操作习惯时，FileNotFoundException 就不再是你代码中的“神秘访客”，而是可以被你从容预见和处理的普通情况。
祝你在Java的文件操作之路上，畅通无阻！
📚 参考资料 (References)Oracle Java SE Documentation: java.io.FileNotFoundExceptionOracle Java SE Documentation: java.io.FileOracle Java SE Documentation: java.nio.file.PathOracle Java SE Documentation: java.nio.file.PathsOracle Java SE Documentation: java.nio.file.FilesOracle Java Tutorials: Basic I/O - Path OperationsBaeldung: Java – Read File from Classpath (关于从类路径读取资源的优秀教程)