本文深入讲解 Java IO 体系中的三大核心类：File、FileInputStream 和 FileOutputStream。涵盖流的概念分类、File 类的路径操作与局限性、字节输入输出流的源码剖析及核心方法（read/write/close）、线程安全性分析，以及文件复制、加密等实战示例。重点介绍了 try-with-resources 资源管理最佳实践、缓冲流性能优化及 NIO 演进方向，帮助开发者掌握基础文件 IO 操作技巧。
在 Java 应用程序开发中，文件输入输出（I/O）是最基础且最常见的操作之一。无论是读取配置文件、处理用户上传的文档、记录日志信息，还是进行数据持久化，都离不开对文件的操作。Java 的 I/O 体系通过"流"（Stream）的抽象，为开发者提供了一套统一而强大的 API 来处理各种设备间的数据传递。
本文将深入剖析 Java 文件 IO 的三大基石：
我们将从源码层面解读其设计原理，探讨核心方法的使用技巧，分析性能优化的关键点，并提供最佳实践指南。
在 Java 中，流是一个抽象的概念，代表了数据的"流动"。可以将其想象为连接数据源（源端）和程序（目的端）的一条管道，数据在管道中按顺序传输。
输入流（Input Stream）：数据从外部源（如文件、网络、键盘）流入程序（内存）。程序从输入流中读取数据。
输出流（Output Stream）：数据从程序（内存）流向外部目的地（如文件、网络、屏幕）。程序向输出流中写入数据。
Java 的 IO 流体系可以从三个维度进行分类：
| 分类维度 | 类别 | 说明 | 典型类 |
|---|---|---|---|
| 数据流向 | 输入流 | 读取数据到程序 | InputStream, Reader |
| 输出流 | 从程序写出数据 | OutputStream, Writer | |
| 操作单位 | 字节流 | 以字节（8 位）为单位 | InputStream, OutputStream |
| 字符流 | 以字符（16 位）为单位 | Reader, Writer | |
| 角色分工 | 节点流 | 直接从数据源读写 | FileInputStream, FileOutputStream |
| 处理流 | 包装节点流，提供增强功能 | BufferedInputStream, DataInputStream |
字节流 vs 字符流：
节点流 vs 处理流：
本文聚焦于文件 IO 的基础字节流：
这三者构成了 Java 进行原始文件操作的基础。理解它们的工作原理，是掌握更高级 IO（如缓冲流、对象流、NIO）的前提。
java.io.File类是 Java IO 体系中唯一代表文件和目录路径名的类，但它不负责文件内容的读写。它更像是一个文件或目录的"名片"，记录了路径信息，并提供了对文件元数据（属性）的操作方法。
public class File implements Serializable, Comparable<File> {
// 文件系统相关的操作接口（与具体操作系统交互）
private static final FileSystem fs = DefaultFileSystem.getFileSystem();
// 核心字段：存储文件的路径
private final String path;
// 路径的规范化状态
private transient volatile PathStatus status = null;
// 文件路径的规范化字符串
private volatile transient String prefixLength;
// 构造方法
public File(String pathname) {
if (pathname == null) {
throw new NullPointerException();
}
this.path = fs.normalize(pathname);
}
// ...
}
关键分析：
File类实现了Serializable接口，意味着File对象可以被序列化Comparable<File>接口，提供了compareTo方法，可以按路径名字典序比较path被final修饰，说明File对象是不可变的——一旦创建，其代表的抽象路径名就不能改变FileSystem fs是与底层操作系统交互的关键，所有与文件系统相关的操作（如检查文件是否存在、获取文件属性）最终都委托给它File 类提供了多种构造方法，灵活适应不同的使用场景：
public class FileConstructorDemo {
public static void main(String[] args) {
// 1. 通过完整路径名字符串创建
File file1 = new File("D:\\data\\document.txt"); // Windows 路径需转义
File file2 = new File("/home/user/document.txt"); // Linux/Mac 路径
// 2. 通过父路径和子路径字符串创建
String parent = "D:\\data";
String child = "document.txt";
File file3 = new File(parent, child);
// 3. 通过父 File 对象和子路径字符串创建
File parentDir = new File("D:\\data");
File file4 = new File(parentDir, "document.txt");
// 4. 通过 URI 创建（略）
}
}
重要说明：
new File()只是在内存中创建了一个对象，代表一个路径，并不会在硬盘上实际创建文件或目录。文件是否真正存在，需要通过exists()方法验证。System.getProperty("user.dir")获取）。在 IDEA 中，单元测试方法的相对路径相对于当前 module，main 方法的相对路径相对于当前工程。路径分隔符：Windows 使用反斜杠\，在 Java 字符串中需要转义为\\u005c；Unix/Linux/Mac 使用正斜杠/。更好的做法是使用File.separator常量，它会根据运行平台自动适配：
File file = new File("D:" + File.separator + "data" + File.separator + "document.txt");
File 类的 API 主要分为四大类：获取基本信息、判断功能、列出目录内容、创建删除操作。
import java.io.File;
import java.util.Date;
public class FileGetInfoDemo {
public static void main(String[] args) {
File file = new File("test.txt");
System.out.println("文件名: " + file.getName()); // test.txt
System.out.println("路径: " + file.getPath()); // test.txt（构造时的路径）
System.out.println("绝对路径: " + file.getAbsolutePath()); // 完整绝对路径
try {
System.out.println("规范路径: " + file.getCanonicalPath()); // 解析.和..的绝对路径
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("父目录: " + file.getParent()); // null（如果没有父目录）
System.out.println("文件大小: " + file.length() + " 字节"); // 文件实际大小
System.out.println("最后修改时间: " + new Date(file.lastModified())); // 毫秒值
}
}
关键点：
length()返回 0 的情况：文件不存在，或者文件确实为空lastModified()返回的是从 1970-01-01 UTC 开始的毫秒数getAbsolutePath()与getCanonicalPath()的区别：绝对路径可能包含.或..，规范路径会解析这些相对引用import java.io.File;
public class FileCheckDemo {
public static void main(String[] args) {
File file = new File("test.txt");
System.out.println("是否存在: " + file.exists()); // true/false
System.out.println("是否是文件: " + file.isFile()); // true
System.out.println("是否是目录: " + file.isDirectory()); // false
System.out.println("是否可读: " + file.canRead()); // 权限检查
System.out.println("是否可写: " + file.canWrite()); // 权限检查
System.out.println("是否可执行: " + file.canExecute()); // 对于文件是可执行权限，对于目录是可遍历权限
System.out.println("是否隐藏: " + file.isHidden()); // 平台相关
}
}
注意：isFile()和isDirectory()在文件不存在时都返回false，不是抛出异常。
import java.io.File;
public class FileListDemo {
public static void main(String[] args) {
File dir = new File("D:\\data");
if (dir.exists() && dir.isDirectory()) {
// 方法 1：返回字符串数组（仅名称）
String[] fileNames = dir.list();
System.out.println("目录中的文件和子目录：");
for (String name : fileNames) {
System.out.println(" " + name);
}
// 方法 2：返回 File 对象数组（完整路径）
File[] files = dir.listFiles();
System.out.println("\nFile 对象列表：");
for (File f : files) {
System.out.println(" " + f.getPath() + (f.isDirectory() ? " [目录]" : " [文件]"));
}
// 带文件名过滤器的版本
File[] txtFiles = dir.listFiles((d, name) -> name.endsWith(".txt"));
System.out.println("\n文本文件：");
for (File f : txtFiles) {
System.out.println(" " + f.getName());
}
}
}
}
源码分析：listFiles()最终会调用FileSystem的list()方法，这是一个 native 方法，与操作系统交互获取目录内容。
import java.io.File;
import java.io.IOException;
public class FileCreateDeleteDemo {
public static void main(String[] args) {
// 1. 创建文件
File file = new File("newfile.txt");
try {
if (file.createNewFile()) {
System.out.println("文件创建成功：" + file.getName());
} else {
System.out.println("文件已存在，无需创建");
}
} catch (IOException e) {
System.out.println("创建文件时发生 IO 错误");
e.printStackTrace();
}
// 2. 创建单级目录
File singleDir = new File("mydir");
if (singleDir.mkdir()) {
System.out.println("目录创建成功：" + singleDir.getName());
} else {
System.out.println("目录创建失败（可能已存在或父目录不存在）");
}
// 3. 创建多级目录
File multiDir = new File("parent/child/grandchild");
if (multiDir.mkdirs()) {
System.out.println("多级目录创建成功：" + multiDir.getPath());
} else {
System.out.println("多级目录创建失败");
}
// 4. 删除文件或空目录
if (file.delete()) {
System.out.println("文件删除成功");
} else {
System.out.println("文件删除失败（可能不存在或无权限）");
}
// 5. 程序退出时自动删除
File tempFile = new File("temp.txt");
try {
if (tempFile.createNewFile()) {
tempFile.deleteOnExit(); // JVM 退出时删除
System.out.println("临时文件将在程序退出时删除");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
重要说明：
createNewFile()：原子操作，检查文件是否存在并创建，返回 boolean 表示是否成功创建mkdir() vs mkdirs()：前者要求父目录必须存在，后者会创建所有不存在的父目录delete()：直接删除，不走回收站，需谨慎操作deleteOnExit()：注册一个钩子，在 JVM 正常退出时删除文件，适用于临时文件清理import java.io.File;
public class FileRenameDemo {
public static void main(String[] args) {
File oldFile = new File("oldname.txt");
File newFile = new File("newname.txt");
// 确保原文件存在
try {
oldFile.createNewFile();
} catch (Exception e) {
e.printStackTrace();
}
// 重命名/移动
if (oldFile.renameTo(newFile)) {
System.out.println("重命名成功");
System.out.println("新文件存在：" + newFile.exists());
System.out.println("旧文件存在：" + oldFile.exists());
} else {
System.out.println("重命名失败");
}
}
}
关键点：
renameTo(File dest)的行为依赖于平台import java.io.File;
public class DirectoryTraversal {
public static void traverse(File dir, String indent) {
if (!dir.exists() || !dir.isDirectory()) {
System.out.println(indent + dir.getPath() + " (不是有效目录)");
return;
}
File[] files = dir.listFiles();
if (files == null) return;
for (File file : files) {
if (file.isDirectory()) {
System.out.println(indent + "[DIR] " + file.getName());
traverse(file, indent + " "); // 递归
} else {
System.out.println(indent + "[FILE] " + file.getName() + " (" + file.length() + " 字节)");
}
}
}
public static void main(String[] args) {
File root = new File("D:\\data");
traverse(root, "");
}
}
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
public class FileFilterDemo {
public static void main(String[] args) {
File dir = new File("D:\\data");
// 使用 FilenameFilter（过滤文件名）
String[] images = dir.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".jpg") || name.endsWith(".png");
}
});
// 使用 FileFilter（过滤 File 对象）
File[] largeFiles = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isFile() && pathname.length() > 1024 * 1024; // > 1MB
}
});
// Lambda 简化版
File[] hiddenFiles = dir.listFiles(f -> f.isHidden());
}
}
尽管 File 类是文件操作的基础，但它存在一些局限性：
JDK 7 引入了java.nio.file.Path和Files类，提供了更强大的文件操作功能，但在基础学习中，File 类仍然是入门文件 IO 的第一步。
java.io.FileInputStream是字节文件输入流，用于从文件中读取原始字节数据。它是InputStream抽象类的直接子类，适用于读取二进制文件（如图片、音频、视频）或任何需要按字节处理的文件。
public class FileInputStream extends InputStream
继承关系：
java.lang.Object └── java.io.InputStream └── java.io.FileInputStream
FileInputStream继承了InputStream，因此它拥有所有输入流的基本方法：read()、read(byte[])、close()等，并根据文件读取的特性进行了实现。
public class FileInputStream extends InputStream {
/* 文件描述符，用于打开文件的句柄 */
private final FileDescriptor fd;
/* 引用文件的路径，如果流是通过文件描述符创建时该值为 null */
private final String path;
/* 文件通道，用于 NIO 操作 */
private FileChannel channel = null;
/* 关闭锁，确保 close 操作的线程安全性 */
private final Object closeLock = new Object();
/* 标记流是否已关闭 */
private volatile boolean closed = false;
// ... 其他代码
}
字段解读：
FileDescriptor创建的，则此字段为null。getChannel()时才会创建。close()方法，防止多个线程同时关闭导致的问题。volatile修饰，确保多线程间的可见性。FileInputStream 提供了三种重载的构造方法：
// 1. 通过文件路径名字符串创建
public FileInputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null);
}
// 2. 通过 File 对象创建（最常用）
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name); // 安全检查：是否有读取权限
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this); // 将当前流关联到文件描述符
path = name;
open(name); // 调用 native 方法打开文件
}
// 3. 通过已有的 FileDescriptor 创建
public FileInputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkRead(fdObj);
}
fd = fdObj;
path = null;
fd.attach(this); // 将当前流关联到已存在的文件描述符
}
构造过程分析：
SecurityManager）FileDescriptor对象attach(this)将文件描述符与当前流关联，便于后续资源释放open(name)本地方法，真正与操作系统交互打开文件FileNotFoundException核心 native 方法：
private native void open(String name) throws FileNotFoundException;
这个 native 方法会调用操作系统的 API（如 Windows 的CreateFile，Linux 的open）来打开文件，获取文件句柄存储在fd中。
public int read() throws IOException {
return read0();
}
private native int read0() throws IOException;
工作原理：
性能考量：每次读取一个字节意味着每个字节都要进行一次系统调用，对于大文件来说效率极低。实际开发中几乎不使用此方法读取大量数据。
public int read(byte b[]) throws IOException {
return readBytes(b, 0, b.length);
}
public int read(byte b[], int off, int len) throws IOException {
return readBytes(b, off, len);
}
private native int readBytes(byte b[], int off, int len) throws IOException;
工作原理：
b.length个字节到数组中readBytes会尽可能多地读取数据，但受限于文件剩余字节数off，将数据存入数组的指定位置示例代码：
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamReadDemo {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("test.dat")) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
// 处理读取到的数据，注意只处理 bytesRead 个字节
// buffer 中可能只有部分数据是有效的
processData(buffer, bytesRead);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void processData(byte[] data, int length) {
// 处理前 length 个字节
System.out.println("读取到 " + length + " 字节");
}
}
重要提示：fis.read(buffer)返回的是实际读取的字节数，这个数值可能小于 buffer 的长度（特别是在接近文件末尾时）。处理数据时必须使用返回的长度，而不是buffer.length。
public native long skip(long n) throws IOException;
工作原理：
skip(-1)）示例：
FileInputStream fis = new FileInputStream("data.bin");
fis.skip(10); // 跳过前 10 个字节
int b = fis.read(); // 读取第 11 个字节
public native int available() throws IOException;
工作原理：
常见误用：
// 错误：用 available() 确定文件大小
FileInputStream fis = new FileInputStream("file.txt");
byte[] data = new byte[fis.available()]; // 可能太小，也可能太大
fis.read(data); // 可能无法填满缓冲区
正确用法：仅用于非阻塞场景的提示，不能替代循环读取。
public void close() throws IOException {
synchronized (closeLock) {
if (closed) {
return;
}
closed = true;
}
if (channel != null) {
channel.close();
}
// 关闭文件描述符
fd.closeAll(new Closeable() {
public void close() throws IOException {
close0();
}
});
}
private native void close0() throws IOException;
设计要点：
closeLock保证线程安全，防止重复关闭FileChannel，一并关闭fd.closeAll()最终调用 native 方法close0()释放系统资源public FileChannel getChannel() {
synchronized (this) {
if (channel == null) {
channel = FileChannelImpl.open(fd, path, true, false, this);
}
return channel;
}
}
作用：返回与此文件输入流关联的唯一的FileChannel对象。这是 Java NIO 的入口，可以进行更高效的文件操作（如内存映射文件、文件锁定等）。
FileInputStream的实例方法本身不是线程安全的，但它的某些操作具有原子性。
通过多线程测试可以发现：单次 read 操作本身不会被其他线程抢占而中断，它会完整地读取这次要读取的内容。但是，由于其他线程可以改变输入流的位置（通过skip或read），每个线程读取时开始的位置是不可预知的。
// 来自并发编程网的测试代码
public class FileThreadTest implements Runnable {
private int type; // 0 做 skip 操作，1 做读取操作
private int gap;
private FileInputStream in;
// ... 构造方法
@Override
public void run() {
byte[] body = new byte[gap];
if (this.type == 0) {
// 执行 skip 操作
} else {
// 执行 read 操作
try {
for (int i = 0; i < 10; i++) {
in.read(body);
System.out.println(Thread.currentThread().getName() + "-" + new String(body));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
测试结果表明：
read()调用是原子的，会读取完整的一组字节import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamExample {
public static void main(String[] args) {
// JDK 7+ try-with-resources 自动关闭流
try (FileInputStream fis = new FileInputStream("input.dat")) {
byte[] buffer = new byte[4096]; // 4KB 缓冲区
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
// 处理数据
System.out.println("读取了 " + bytesRead + " 字节");
// 例如：将字节写入其他流、解析数据等
}
} catch (IOException e) {
System.err.println("文件读取错误：" + e.getMessage());
}
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopyExample {
public static void copyFile(String source, String dest) throws IOException {
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dest)) {
byte[] buffer = new byte[8192]; // 8KB 缓冲区
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
} // 自动关闭两个流
}
public static void main(String[] args) {
try {
copyFile("source.jpg", "copy.jpg");
System.out.println("文件复制成功");
} catch (IOException e) {
System.err.println("复制失败：" + e.getMessage());
}
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class ReadPartialExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("data.bin")) {
byte[] header = new byte[10]; // 读取文件头 10 字节
byte[] body = new byte[100]; // 读取接下来的 100 字节
int headerRead = fis.read(header);
if (headerRead == 10) {
System.out.println("文件头读取成功");
}
int bodyRead = fis.read(body);
System.out.println("读取了 " + bodyRead + " 字节的正文");
} catch (IOException e) {
e.printStackTrace();
}
}
}
while ((b = fis.read()) != -1)是性能杀手FileChannel和内存映射文件性能更好使用缓冲流：FileInputStream每次读取都会触发系统调用。包装为BufferedInputStream可大幅减少系统调用次数：
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("large.dat"))) {
// 读取效率更高
}
java.io.FileOutputStream是字节文件输出流，用于将原始字节数据写入文件。它是OutputStream抽象类的直接子类，与FileInputStream对应。
public class FileOutputStream extends OutputStream
继承关系：
java.lang.Object └── java.io.OutputStream └── java.io.FileOutputStream
public class FileOutputStream extends OutputStream {
/* 文件描述符 */
private final FileDescriptor fd;
/* 文件路径 */
private final String path;
/* 是否以追加模式打开 */
private final boolean append;
/* 文件通道 */
private FileChannel channel;
/* 关闭锁 */
private final Object closeLock = new Object();
/* 是否已关闭 */
private volatile boolean closed = false;
// ...
}
与 FileInputStream 不同的字段：
true表示写入的数据追加到文件末尾，false表示覆盖文件开头。FileOutputStream 提供了 5 个重载的构造方法：
// 1. 通过文件名创建（覆盖模式）
public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}
// 2. 通过文件名创建，指定是否追加
public FileOutputStream(String name, boolean append) throws FileNotFoundException {
this(name != null ? new File(name) : null, append);
}
// 3. 通过 File 对象创建（覆盖模式）
public FileOutputStream(File file) throws FileNotFoundException {
this(file, false);
}
// 4. 通过 File 对象创建，指定是否追加
public FileOutputStream(File file, boolean append) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkWrite(name); // 安全检查：是否有写入权限
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
this.fd = new FileDescriptor();
this.append = append;
this.path = name;
// 根据追加模式打开文件
open(name, append);
}
// 5. 通过 FileDescriptor 创建
public FileOutputStream(FileDescriptor fdObj) {
SecurityManager security = System.getSecurityManager();
if (fdObj == null) {
throw new NullPointerException();
}
if (security != null) {
security.checkWrite(fdObj);
}
this.fd = fdObj;
this.path = null;
this.append = false;
fd.attach(this);
}
核心 native 方法：
private native void open(String name, boolean append) throws FileNotFoundException;
打开模式说明：
append = false（默认）：文件指针定位到文件开头。如果文件已存在，原有内容会被新写入的内容覆盖append = true：文件指针定位到文件末尾，新写入的内容追加到原内容之后public void write(int b) throws IOException {
write(b, append);
}
private native void write(int b, boolean append) throws IOException;
工作原理：
性能考量：与FileInputStream.read()类似，单字节写入效率极低，不推荐大量使用。
public void write(byte b[]) throws IOException {
writeBytes(b, 0, b.length, append);
}
public void write(byte b[], int off, int len) throws IOException {
writeBytes(b, off, len, append);
}
private native void writeBytes(byte b[], int off, int len, boolean append) throws IOException;
工作原理：
public void close() throws IOException {
synchronized (closeLock) {
if (closed) {
return;
}
closed = true;
}
if (channel != null) {
channel.close();
}
fd.closeAll(new Closeable() {
public void close() throws IOException {
close0();
}
});
}
private native void close0() throws IOException;
与 FileInputStream 类似：使用锁保证线程安全，关闭关联的通道，释放系统资源。
public FileChannel getChannel() {
synchronized (this) {
if (channel == null) {
channel = FileChannelImpl.open(fd, path, false, true, append, this);
}
return channel;
}
}
public final FileDescriptor getFD() throws IOException {
if (fd != null) return fd;
throw new IOException();
}
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamBasicExample {
public static void main(String[] args) {
String data = "Hello, Java IO!";
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
// 将字符串转换为字节数组写入
fos.write(data.getBytes());
// 也可以逐字节写入（不推荐）
// for (byte b : data.getBytes()) {
// fos.write(b);
// }
System.out.println("数据写入成功");
} catch (IOException e) {
System.err.println("写入失败：" + e.getMessage());
}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class AppendVsOverwrite {
public static void main(String[] args) {
// 覆盖模式
try (FileOutputStream fos = new FileOutputStream("test.txt")) {
fos.write("First line\n".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
// 再次写入（覆盖模式）
try (FileOutputStream fos = new FileOutputStream("test.txt")) {
fos.write("Second line\n".getBytes()); // 原内容被覆盖
} catch (IOException e) {
e.printStackTrace();
}
// 追加模式
try (FileOutputStream fos = new FileOutputStream("test.txt", true)) {
fos.write("Third line\n".getBytes()); // 追加到末尾
} catch (IOException e) {
e.printStackTrace();
}
}
}
执行后，test.txt 内容为：
Second line Third line
import java.io.FileOutputStream;
import java.io.IOException;
public class WriteBinaryExample {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("binary.dat")) {
// 写入 int 类型（4 字节）
int value = 12345678;
fos.write((value >>> 24) & 0xFF); // 高位字节
fos.write((value >>> 16) & 0xFF);
fos.write((value >>> 8) & 0xFF);
fos.write(value & 0xFF); // 低位字节
// 或者使用 DataOutputStream 简化
// try (DataOutputStream dos = new DataOutputStream(fos)) {
// dos.writeInt(value);
// }
} catch (IOException e) {
e.printStackTrace();
}
}
}
FileOutputStream会自动创建它（前提是父目录存在）FileNotFoundExceptionFileNotFoundExceptionboolean append参数的构造方法write()方法返回时，数据不一定已经持久化到磁盘，可能还在操作系统缓存中。需要确保数据真正写入可调用getFD().sync()FileInputStream类似，多线程共享同一个FileOutputStream会导致数据交错，需要外部同步或使用每个线程独立的流import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
/**
* 文件复制工具 - 展示多种实现方式
*/
public class FileCopyUtil {
/**
* 方式 1：使用 FileInputStream/FileOutputStream（基础字节流）
*/
public static void copyByStream(String src, String dest) throws IOException {
File srcFile = new File(src);
File destFile = new File(dest);
// 检查源文件是否存在
if (!srcFile.exists()) {
throw new FileNotFoundException("源文件不存在：" + src);
}
// 确保目标文件父目录存在
File parent = destFile.getParentFile();
if (parent != null && !parent.exists()) {
parent.mkdirs();
}
// 使用 try-with-resources 自动关闭资源
try (FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile)) {
byte[] buffer = new byte[8192]; // 8KB 缓冲区
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
fos.flush(); // 确保所有数据写入
}
}
/**
* 方式 2：使用 BufferedInputStream/BufferedOutputStream（缓冲流优化）
*/
public static void copyByBufferedStream(String src, String dest) throws IOException {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest))) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = bis.read(buffer)) != -1) {
bos.write(buffer, 0, bytesRead);
}
bos.flush();
}
}
/**
* 方式 3：使用 FileChannel（NIO，适合大文件）
*/
public static void copyByChannel(String src, String dest) throws IOException {
try (FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
FileChannel inChannel = fis.getChannel();
FileChannel outChannel = fos.getChannel()) {
// 直接传输，无需手动缓冲区
inChannel.transferTo(0, inChannel.size(), outChannel);
}
}
/**
* 方式 4：使用 Files 工具类（Java 7+，最简单）
*/
public static void copyByFiles(String src, String dest) throws IOException {
Path sourcePath = Paths.get(src);
Path destPath = Paths.get(dest);
Files.copy(sourcePath, destPath, StandardCopyOption.REPLACE_EXISTING);
}
/**
* 性能测试
*/
public static void performanceTest(String src, String dest) {
long start, end;
try {
// 测试基础流
start = System.currentTimeMillis();
copyByStream(src, dest + ".stream");
end = System.currentTimeMillis();
System.out.println("基础流耗时：" + (end - start) + "ms");
// 测试缓冲流
start = System.currentTimeMillis();
copyByBufferedStream(src, dest + ".buffered");
end = System.currentTimeMillis();
System.out.println("缓冲流耗时：" + (end - start) + "ms");
// 测试 NIO 通道
start = System.currentTimeMillis();
copyByChannel(src, dest + ".channel");
end = System.currentTimeMillis();
System.out.println("NIO 通道耗时：" + (end - start) + "ms");
// 测试 Files 工具类
start = System.currentTimeMillis();
copyByFiles(src, dest + ".files");
end = System.currentTimeMillis();
System.out.println("Files 工具类耗时：" + (end - start) + "ms");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("用法：java FileCopyUtil <源文件> <目标文件>");
return;
}
try {
copyByStream(args[0], args[1]);
System.out.println("文件复制成功");
} catch (IOException e) {
System.err.println("复制失败：" + e.getMessage());
}
}
}
import java.io.*;
/**
* 简单的文件加密/解密工具（使用异或算法）
* 相同的程序执行两次即可解密（异或的特性：a XOR key XOR key = a）
*/
public class FileCipher {
private static final byte DEFAULT_KEY = 0x7F; // 加密密钥
/**
* 加密/解密文件
*/
public static void processFile(String src, String dest, byte key) throws IOException {
try (FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest)) {
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
// 对每个字节进行异或运算
for (int i = 0; i < bytesRead; i++) {
buffer[i] ^= key;
}
fos.write(buffer, 0, bytesRead);
}
}
}
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("用法：java FileCipher <源文件> <目标文件> [密钥]");
return;
}
String src = args[0];
String dest = args[1];
byte key = args.length > 2 ? Byte.parseByte(args[2]) : DEFAULT_KEY;
try {
processFile(src, dest, key);
System.out.println("文件处理完成");
} catch (IOException e) {
System.err.println("处理失败：" + e.getMessage());
}
}
}
import java.io.*;
import java.util.Properties;
/**
* 读取配置文件示例
*/
public class ConfigReader {
private Properties props = new Properties();
/**
* 从文件加载配置
*/
public void loadConfig(String configFile) throws IOException {
try (FileInputStream fis = new FileInputStream(configFile)) {
props.load(fis); // Properties 提供了 load(InputStream) 方法
}
}
/**
* 保存配置到文件
*/
public void saveConfig(String configFile) throws IOException {
try (FileOutputStream fos = new FileOutputStream(configFile)) {
props.store(fos, "Configuration File");
}
}
/**
* 手动解析配置文件（演示 FileInputStream 用法）
*/
public void manualParseConfig(String configFile) throws IOException {
try (FileInputStream fis = new FileInputStream(configFile)) {
byte[] buffer = new byte[1024];
int bytesRead = fis.read(buffer);
if (bytesRead > 0) {
String content = new String(buffer, 0, bytesRead);
String[] lines = content.split("\n");
for (String line : lines) {
line = line.trim();
if (line.isEmpty() || line.startsWith("#")) {
continue; // 忽略空行和注释
}
int eqIndex = line.indexOf('=');
if (eqIndex > 0) {
String key = line.substring(0, eqIndex).trim();
String value = line.substring(eqIndex + 1).trim();
props.setProperty(key, value);
}
}
}
}
}
public String getProperty(String key) {
return props.getProperty(key);
}
public static void main(String[] args) {
ConfigReader reader = new ConfigReader();
try {
reader.loadConfig("config.properties");
System.out.println("db.url = " + reader.getProperty("db.url"));
System.out.println("db.username = " + reader.getProperty("db.username"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
JDK 7 引入的 try-with-resources 语句是处理 IO 资源的最佳实践：
// 传统方式（JDK 6 及以前）
FileInputStream fis = null;
try {
fis = new FileInputStream("file.txt"); // 读取操作
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// try-with-resources 方式（JDK 7+）
try (FileInputStream fis = new FileInputStream("file.txt");
FileOutputStream fos = new FileOutputStream("out.txt")) {
// 读取和写入操作
} catch (IOException e) {
e.printStackTrace();
}
// 自动关闭 fis 和 fos，无需 finally
优点：
现象：在 Windows 上，如果文件已被其他程序打开，再尝试写入会抛出FileNotFoundException。
解决方案：
FileChannel的tryLock()尝试获取文件锁RandomAccessFile现象：写入文件时父目录不存在，抛出FileNotFoundException。
解决方案：
File file = new File("parent/child/data.txt");
File parent = file.getParentFile();
if (parent != null && !parent.exists()) {
parent.mkdirs(); // 创建所有不存在的父目录
}
try (FileOutputStream fos = new FileOutputStream(file)) {
// 写入数据
}
现象：使用FileOutputStream写入文本时，出现乱码。
解决方案：
使用字符流FileWriter（可指定编码）：
try (FileWriter fw = new FileWriter("file.txt", StandardCharsets.UTF_8)) {
fw.write(text);
}
明确指定字符编码：
String text = "中文内容";
try (FileOutputStream fos = new FileOutputStream("file.txt")) {
fos.write(text.getBytes(StandardCharsets.UTF_8));
}
现象：读写大文件时速度很慢。
解决方案：
new BufferedInputStream(new FileInputStream(...))FileChannel.transferTo()或内存映射文件| 特性 | File | FileInputStream | FileOutputStream |
|---|---|---|---|
| 主要作用 | 文件和目录路径名操作 | 从文件读取字节数据 | 向文件写入字节数据 |
| 核心功能 | 创建、删除、重命名、查询属性 | 读取字节数组/单个字节 | 写入字节数组/单个字节 |
| 是否处理内容 | 否（只处理元数据） | 是 | 是 |
| 数据流向 | N/A | 文件 → 程序 | 程序 → 文件 |
| 线程安全 | 是（不可变对象） | 否（需要外部同步） | 否（需要外部同步） |
| 异常处理 | 部分方法返回 boolean | IOException | IOException |
| JDK 版本 | 1.0 | 1.0 | 1.0 |
本文深入讲解了 File、FileInputStream 和 FileOutputStream 这三个基础的 IO 类。在实际开发中，我们通常不会直接使用它们，而是基于它们构建更高级的 IO 处理：
BufferedInputStream/BufferedOutputStream - 减少系统调用次数DataInputStream/DataOutputStream - 读写 Java 基本数据类型ObjectInputStream/ObjectOutputStream - 对象序列化FileReader/FileWriter - 专门处理文本文件Files、Path、FileChannel - 更现代、更强大的文件操作随着 Java 的发展，文件 IO 也在不断演进：
Path、Files类，提供了更全面的文件操作 APIFiles类的方法，支持 Stream API 遍历目录Files.readString()和Files.writeString()简化文本文件读写byte[] allBytes = Files.readAllBytes(Paths.get("file.dat"));
List<String> lines = Files.readAllLines(Paths.get("file.txt"), StandardCharsets.UTF_8);
Files.write(Paths.get("file.txt"), "Hello".getBytes(StandardCharsets.UTF_8));
Files.list(Paths.get(".")).forEach(System.out::println);
Files.walk(Paths.get(".")).filter(Files::isRegularFile).forEach(System.out::println);
Path tempFile = Files.createTempFile("prefix", ".tmp");
Files.copy(Paths.get("source.txt"), Paths.get("dest.txt"), StandardCopyOption.REPLACE_EXISTING);
long size = Files.size(Paths.get("file.txt"));
boolean exists = Files.exists(Paths.get("file.txt"));
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online