Java IO 流：核心原理与实战应用指南

代码实操 1：单字节读取文件

import java.io.FileInputStream;
import java.io.IOException;

/**
 * FileInputStream 单字节读取文件
 */
public class FileInputStreamDemo1 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 1. 创建字节输入流对象，绑定数据源
            fis = new FileInputStream("test.txt");
            // 2. 读取数据：read() 方法每次读取一个字节，返回读取的字节值，读到末尾返回 -1
            int readByte;
            while ((readByte = fis.read()) != -1) {
                // 字节转字符输出（适用于文本文件）
                System.out.print((char) readByte);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流资源
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

⚠️ 注意事项：单字节读取效率极低，因为每次都要访问磁盘，适合小文件读取，大文件不推荐使用。

代码实操 2：字节数组读取文件

import java.io.FileInputStream;
import java.io.IOException;

/**
 * FileInputStream 字节数组读取文件（高效读取）
 */
public class FileInputStreamDemo2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test.txt");
            // 定义字节数组缓冲区，大小一般为 1024 的倍数
            byte[] buffer = new byte[1024];
            // read(byte[] b)：读取字节到数组中，返回读取的有效字节数，末尾返回 -1
            int len;
            while ((len = fis.read(buffer)) != -1) {
                // 将字节数组转换为字符串，注意取有效长度 len
                System.out.print(new String(buffer, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

✅ 核心结论：字节数组读取是 推荐的高效读取方式，通过缓冲区减少磁盘 IO 次数，大幅提升读取效率。

1.3.2 字节输出流（FileOutputStream）

FileOutputStream 是最常用的字节输出流，用于向文件中写入字节数据，支持覆盖写入和追加写入两种模式。

基本使用步骤

1. 创建 FileOutputStream 对象，绑定目标文件路径。
2. 调用 write() 方法写入数据。
3. 关闭流资源。

代码实操 1：覆盖写入文件

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * FileOutputStream 覆盖写入文件
 */
public class FileOutputStreamDemo1 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            // 1. 创建字节输出流对象，默认覆盖写入模式
            fos = new FileOutputStream("output.txt");
            // 2. 写入数据
            // 方式 1：写入单个字节
            fos.write(97); // 写入字符'a'的 ASCII 码
            // 方式 2：写入字节数组
            byte[] bytes = "Hello FileOutputStream".getBytes();
            fos.write(bytes);
            // 方式 3：写入字节数组的指定部分
            byte[] partBytes = "Java IO Stream".getBytes();
            fos.write(partBytes, 0, 4); // 只写入前 4 个字节"Java"
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流资源
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

代码实操 2：追加写入文件

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * FileOutputStream 追加写入文件
 */
public class FileOutputStreamDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            // 构造方法第二个参数为 true 时，开启追加写入模式
            fos = new FileOutputStream("output.txt", true);
            // 写入换行符（不同系统换行符不同：Windows->\r\n，Linux->\n）
            fos.write("\r\n".getBytes());
            // 追加写入新内容
            fos.write("这是追加的内容".getBytes());
            System.out.println("内容追加成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

⚠️ 注意事项：写入文件时，如果目标文件不存在，FileOutputStream 会自动创建文件；如果父目录不存在，则会抛出 FileNotFoundException。

1.3.3 实战：字节流实现文件拷贝

文件拷贝是 IO 流的典型应用场景，通过字节输入流读取源文件数据，再通过字节输出流写入目标文件，可实现任意类型文件的拷贝。

代码实现

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 字节流实现文件拷贝（支持所有类型文件：文本、图片、视频等）
 */
public class FileCopyDemo {
    public static void main(String[] args) {
        // 源文件路径和目标文件路径
        String sourcePath = "source.jpg";
        String targetPath = "target_copy.jpg";
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            // 1. 创建字节输入流和输出流
            fis = new FileInputStream(sourcePath);
            fos = new FileOutputStream(targetPath);
            // 2. 定义缓冲区，提升拷贝效率
            byte[] buffer = new byte[1024 * 8]; // 8KB 缓冲区
            int len;
            // 3. 循环读取并写入数据
            long startTime = System.currentTimeMillis();
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("文件拷贝成功！耗时：" + (endTime - startTime) + "ms");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 关闭流资源，先关输出流，再关输入流
            try {
                if (fos != null) fos.close();
                if (fis != null) fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

✅ 核心结论：字节流拷贝文件的核心是 边读边写，通过合理设置缓冲区大小（如 8KB、16KB），可以大幅提升拷贝效率，这是文件拷贝的标准实现方式。

1.4 字符流的核心用法

1.4.1 字符流的设计初衷

字节流处理文本文件时，需要手动处理字符编码问题，容易出现乱码。字符流以字符为单位处理数据，内部集成了编码解码逻辑，专门用于处理文本文件，避免乱码问题。

字符流与字节流的核心区别：字节流处理字节，字符流处理字符；字符流底层还是基于字节流实现，只是多了编码解码的步骤。

1.4.2 字符输入流（FileReader）

基本使用步骤

1. 创建 FileReader 对象，绑定数据源文本文件。
2. 调用 read() 方法读取字符数据。
3. 关闭流资源。

代码实操：字符数组读取文本文件

import java.io.FileReader;
import java.io.IOException;

/**
 * FileReader 读取文本文件
 */
public class FileReaderDemo {
    public static void main(String[] args) {
        FileReader fr = null;
        try {
            // 1. 创建字符输入流对象，默认使用系统编码
            fr = new FileReader("test.txt");
            // 2. 字符数组读取数据
            char[] buffer = new char[1024];
            int len;
            while ((len = fr.read(buffer)) != -1) {
                // 直接转换为字符串输出，无需手动处理编码
                System.out.print(new String(buffer, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流资源
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.4.3 字符输出流（FileWriter）

基本使用步骤

1. 创建 FileWriter 对象，绑定目标文本文件。
2. 调用 write() 方法写入字符数据。
3. 调用 flush() 方法刷新缓冲区（可选），关闭流资源。

代码实操：字符流写入文本文件

import java.io.FileWriter;
import java.io.IOException;

/**
 * FileWriter 写入文本文件
 */
public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            // 1. 创建字符输出流对象，开启追加写入模式
            fw = new FileWriter("text_output.txt", true);
            // 2. 写入数据
            // 方式 1：写入单个字符
            fw.write('J');
            // 方式 2：写入字符数组
            char[] chars = {'a', 'v', 'a'};
            fw.write(chars);
            // 方式 3：写入字符串（最常用）
            fw.write(" 字符流写入测试\r\n");
            // 刷新缓冲区：将缓冲区数据写入文件，流可以继续使用
            fw.flush();
            fw.write("刷新后继续写入的内容");
            System.out.println("文本写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流资源：close() 方法会自动调用 flush()
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

⚠️ 注意事项：字符流的 flush() 方法用于将缓冲区数据写入文件，close() 方法会自动调用 flush()；字节流没有缓冲区，无需调用 flush()。

1.5 高级 IO 流的实战应用

1.5.1 缓冲流：提升 IO 操作效率

缓冲流（BufferedInputStream/BufferedOutputStream、BufferedReader/BufferedWriter）是处理流的一种，通过在内存中创建缓冲区，减少磁盘 IO 次数，大幅提升读写效率。

缓冲流的核心原理：读取数据时，先将数据读取到缓冲区，后续读取直接从缓冲区获取；写入数据时，先写入缓冲区，缓冲区满或关闭流时再写入磁盘。

代码实操 1：缓冲字节流实现高效文件拷贝

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 缓冲字节流实现高效文件拷贝
 */
public class BufferedFileCopyDemo {
    public static void main(String[] args) {
        String sourcePath = "large_file.zip";
        String targetPath = "large_file_copy.zip";
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            // 1. 缓冲流包裹节点流
            bis = new BufferedInputStream(new FileInputStream(sourcePath));
            bos = new BufferedOutputStream(new FileOutputStream(targetPath));
            // 2. 读取写入数据
            byte[] buffer = new byte[1024 * 8];
            int len;
            long startTime = System.currentTimeMillis();
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("大文件拷贝成功！耗时：" + (endTime - startTime) + "ms");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流：关闭缓冲流会自动关闭底层的节点流
            try {
                if (bos != null) bos.close();
                if (bis != null) bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

代码实操 2：缓冲字符流读取文本文件（按行读取）

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * BufferedReader 按行读取文本文件（最常用的文本读取方式）
 */
public class BufferedReaderDemo {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            // 1. 创建缓冲字符输入流
            br = new BufferedReader(new FileReader("test.txt"));
            // 2. 按行读取数据：readLine() 方法返回一行字符串，末尾返回 null
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3. 关闭流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

✅ 核心结论：缓冲流是 提升 IO 效率的首选方式，处理大文件时优势明显；BufferedReader 的 readLine() 方法是读取文本文件的标准方式。

1.5.2 转换流：处理字符编码问题

转换流（InputStreamReader/OutputStreamWriter）是字节流与字符流之间的桥梁，用于指定字符编码读取或写入文本文件，解决乱码问题。

当系统默认编码与文件编码不一致时，必须使用转换流指定编码，否则会出现乱码。

代码实操：指定编码读取文本文件

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * InputStreamReader 指定编码读取文本文件
 */
public class InputStreamReaderDemo {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        try {
            // 1. 创建转换流，指定编码为 UTF-8
            FileInputStream fis = new FileInputStream("utf8_file.txt");
            isr = new InputStreamReader(fis, "UTF-8");
            // 2. 读取数据
            char[] buffer = new char[1024];
            int len;
            while ((len = isr.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

⚠️ 注意事项：转换流的编码参数必须与文件实际编码一致，常见的编码格式有 UTF-8、GBK、GB2312 等。

1.5.3 对象流：实现对象的序列化与反序列化

对象流（ObjectInputStream/ObjectOutputStream）用于将 Java 对象转换为字节序列（序列化），或将字节序列恢复为 Java 对象（反序列化），实现对象的持久化存储或网络传输。

序列化的前提条件

1. 目标对象的类必须实现 Serializable 标记接口（该接口没有任何方法，仅用于标记）。
2. 类中的所有属性必须是可序列化的（基本数据类型默认可序列化，引用类型需实现 Serializable）。
3. 可通过 transient 关键字修饰属性，使其不参与序列化。

代码实操 1：对象序列化

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 对象序列化：将 User 对象写入文件
 */
// 实现 Serializable 接口，标记该类可序列化
class User implements Serializable {
    // 序列化版本号：用于保证序列化和反序列化的类版本一致
    private static final long serialVersionUID = 1L;
    private String username;
    private int age;
    // transient 修饰的属性不参与序列化
    private transient String password;

    public User(String username, int age, String password) {
        this.username = username;
        this.age = age;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" + "username='" + username + '\'' + ", age=" + age + ", password='" + password + "'}";
    }
}

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            // 1. 创建对象输出流
            oos = new ObjectOutputStream(new FileOutputStream("user.obj"));
            // 2. 序列化对象
            User user = new User("zhangsan", 20, "123456");
            oos.writeObject(user);
            System.out.println("对象序列化成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

代码实操 2：对象反序列化

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * 对象反序列化：从文件中恢复 User 对象
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            // 1. 创建对象输入流
            ois = new ObjectInputStream(new FileInputStream("user.obj"));
            // 2. 反序列化对象
            User user = (User) ois.readObject();
            System.out.println("反序列化得到的对象：" + user);
            // 注意：transient 修饰的 password 属性值为 null
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果

反序列化得到的对象：User{username='zhangsan', age=20, password='null'}

✅ 核心结论：对象流是实现对象持久化的核心技术，serialVersionUID 用于保证类版本一致，transient 关键字可排除不需要序列化的属性。

1.6 IO 流的最佳实践与常见问题

1.6.1 IO 流的最佳实践

1. 优先使用缓冲流：缓冲流能大幅提升 IO 效率，处理大文件时必须使用。
2. 合理设置缓冲区大小：缓冲区大小建议设置为 1024 的倍数，如 8KB、16KB，过大或过小都会影响效率。
3. 及时关闭流资源：流资源使用完毕后必须关闭，释放系统资源，推荐使用 try-with-resources 语法自动关闭流。
4. 处理文本文件优先使用字符流：字符流自动处理编码问题，避免乱码；处理非文本文件必须使用字节流。
5. 指定编码格式：读取文本文件时，尽量指定编码格式，避免依赖系统默认编码导致乱码。

1.6.2 常见问题与解决方案

❌ 问题 1：文件找不到异常（FileNotFoundException）

• 原因：文件路径错误、父目录不存在、文件权限不足。
• 解决方案：检查文件路径是否正确；创建父目录；确保程序有文件访问权限。

❌ 问题 2：文本文件读取乱码

• 原因：编码格式不匹配。
• 解决方案：使用转换流 InputStreamReader 指定正确的编码格式。

❌ 问题 3：对象反序列化失败（InvalidClassException）

• 原因：序列化和反序列化的类版本不一致、类未实现 Serializable 接口。
• 解决方案：添加 serialVersionUID；确保类实现 Serializable 接口。

❌ 问题 4：流关闭顺序错误

• 原因：先关闭节点流，再关闭处理流，导致处理流关闭时出错。
• 解决方案：关闭流时先关闭处理流，再关闭节点流；或直接关闭处理流，底层节点流会自动关闭。

1.6.3 try-with-resources 语法自动关闭流

JDK 7 引入的 try-with-resources 语法，可自动关闭实现了 AutoCloseable 接口的资源，无需手动关闭流，代码更简洁，且能避免资源泄漏。

代码实操

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * try-with-resources 自动关闭流
 */
public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // 流对象定义在 try 的括号中，代码执行完毕后自动关闭
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 无需手动关闭流，JVM 自动处理
    }
}

✅ 核心结论：try-with-resources 是 推荐的流资源管理方式，能有效避免因忘记关闭流导致的资源泄漏问题。

1.7 实战案例：文件内容搜索工具

1.7.1 需求分析

实现一个文件内容搜索工具，支持在指定目录下的所有文本文件中搜索指定关键词，并输出包含关键词的文件路径和行内容。

需求如下：

1. 支持指定搜索目录和关键词。
2. 递归遍历目录下的所有文本文件（.txt、.java、.xml 等）。
3. 输出包含关键词的文件路径、行号和行内容。
4. 处理 IO 异常，保证程序健壮性。

1.7.2 代码实现

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * 文件内容搜索工具
 */
public class FileContentSearcher {
    // 支持的文本文件后缀
    private static final String[] SUPPORT_EXTENSIONS = {".txt", ".java", ".xml", ".properties"};

    /**
     * 递归搜索目录下的文件
     * @param dir 搜索目录
     * @param keyword 搜索关键词
     */
    public static void search(File dir, String keyword) {
        // 检查目录是否存在
        if (!dir.exists() || !dir.isDirectory()) {
            System.out.println("目录不存在或不是有效目录！");
            return;
        }
        // 获取目录下的所有文件和子目录
        File[] files = dir.listFiles();
        if (files == null) {
            return;
        }
        for (File file : files) {
            if (file.isDirectory()) {
                // 递归搜索子目录
                search(file, keyword);
            } else {
                // 判断是否为支持的文本文件
                if (isTextFile(file.getName())) {
                    // 搜索文件内容
                    searchFileContent(file, keyword);
                }
            }
        }
    }

    /**
     * 判断是否为支持的文本文件
     * @param fileName 文件名
     * @return 是文本文件返回 true，否则返回 false
     */
    private static boolean isTextFile(String fileName) {
        for (String ext : SUPPORT_EXTENSIONS) {
            if (fileName.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 搜索单个文件的内容
     * @param file 目标文件
     * @param keyword 搜索关键词
     */
    private static void searchFileContent(File file, String keyword) {
        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
            String line;
            int lineNum = 0;
            while ((line = br.readLine()) != null) {
                lineNum++;
                // 判断行内容是否包含关键词
                if (line.contains(keyword)) {
                    System.out.println("====================================");
                    System.out.println("文件路径：" + file.getAbsolutePath());
                    System.out.println("行号：" + lineNum);
                    System.out.println("内容：" + line);
                }
            }
        } catch (IOException e) {
            System.out.println("读取文件失败：" + file.getAbsolutePath());
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 搜索目录和关键词
        String dirPath = "src";
        String keyword = "IO 流";
        File dir = new File(dirPath);
        System.out.println("开始搜索关键词【" + keyword + "】...");
        search(dir, keyword);
        System.out.println("\n搜索完成！");
    }
}

1.7.3 案例总结

这个文件内容搜索工具综合运用了 IO 流的核心知识，核心亮点如下：

1. 使用 BufferedReader 按行读取文本文件，保证读取效率。
2. 递归遍历目录，实现多级目录下的文件搜索。
3. 使用 try-with-resources 自动关闭流，避免资源泄漏。
4. 处理了各种异常情况，保证程序的健壮性。
5. 可灵活扩展支持的文本文件类型，实用性强。

1.8 本章总结

1. IO 流是 Java 处理数据传输的核心技术，分为字节流和字符流，字节流处理所有类型文件，字符流专门处理文本文件。
2. 字节流的核心用法是文件读写和拷贝，通过字节数组读取可提升效率；字符流可避免编码问题，readLine() 是读取文本的标准方式。
3. 缓冲流通过缓冲区减少磁盘 IO 次数，大幅提升 IO 效率；转换流用于处理编码问题；对象流实现对象的序列化与反序列化。
4. IO 流的最佳实践是优先使用缓冲流、及时关闭流资源、指定编码格式、使用 try-with-resources 管理资源。
5. 实际开发中，需根据文件类型选择合适的 IO 流，处理异常情况，保证程序的健壮性。