Java基础IO流全解析：常用知识点与面试高频考点汇总

前言

IO（Input/Output）流是Java中处理数据传输的核心机制，无论是文件操作、网络通信还是数据持久化，都离不开IO流的身影。对于Java初学者而言，IO流的分类多、类库庞大，容易混淆；而在面试中，IO流也是高频考点——从基础分类到缓冲原理，从异常处理到序列化，都是面试官常问的内容。

本文将从基础框架出发，梳理IO流的核心分类与常用API，深入解析面试高频问题，并通过代码示例落地实践，帮你彻底搞懂Java IO流。

一、IO流的整体框架：先理清“分类”再学用法

Java IO流的设计遵循“分层”和“职责单一”原则，整体可通过3个维度进行分类。理解分类是掌握IO流的前提，也是面试基础题的高频考点。

1.1 按“数据流向”分类

这是最直观的分类方式，以程序为参照物，分为输入流和输出流：

输入流（Input Stream）：数据从外部（文件、网络、键盘等）流向程序，用于“读取”数据；
输出流（Output Stream）：数据从程序流向外部，用于“写入”数据。

面试注意：输入/输出是相对程序而言的，比如“读取文件”用输入流，“写入文件”用输出流。

1.2 按“数据单位”分类

这是IO流最核心的分类，决定了流的适用场景：

字节流：以“字节（byte，8位）”为单位传输数据，可处理所有类型数据（文本、图片、音频、视频等）；
字符流：以“字符（char，16位）”为单位传输数据，仅用于处理文本数据（需指定编码，如UTF-8、GBK）。

本质区别：字节流是“无编码依赖”的原始数据传输，字符流是“编码依赖”的文本数据传输（字节→字符的转换需要编码映射）。

1.3 按“角色”分类

按流在数据处理中的职责，分为节点流和处理流（装饰器模式的典型应用）：

节点流（低级流）：直接对接数据源（如文件、内存、网络），是IO流的“基础”；
例：FileInputStream（直接读文件）、ByteArrayInputStream（直接读内存字节数组）。
处理流（高级流）：不直接对接数据源，而是包装“节点流或其他处理流”，增强功能（如缓冲、转换、对象序列化）；
例：BufferedInputStream（缓冲增强）、InputStreamReader（字节→字符转换）。

设计优势：通过“包装”可灵活组合功能，比如“FileInputStream + BufferedInputStream”既实现文件读取，又具备缓冲加速。

1.4 IO流核心分类结构图

用思维导图清晰展示核心流的继承关系（面试常考“流的继承体系”）：

1.5 核心接口与抽象类

Java IO流通过4个核心抽象类定义规范，所有具体流都直接/间接继承它们：

抽象类	数据单位	方向	核心方法
`InputStream`	字节	输入	`int read()`、`read(byte[] b)`
`OutputStream`	字节	输出	`void write(int b)`、`write(byte[] b)`
`Reader`	字符	输入	`int read()`、`read(char[] c)`
`Writer`	字符	输出	`void write(int c)`、`write(char[] c)`

面试考点：这4个类都是抽象类，不能直接实例化，必须使用它们的子类（如FileInputStream）。

二、常用IO流详解：从基础到实战

掌握以下10种常用流的用法，可覆盖90%的日常开发场景，也是面试中“手写IO代码”的高频考点。

2.1 字节流：处理所有数据类型

字节流是IO流的“基础”，可处理任意数据（文本、图片、视频等），核心是FileInputStream/FileOutputStream（节点流）和BufferedInputStream/BufferedOutputStream（处理流）。

（1）FileInputStream & FileOutputStream：文件字节流

直接操作文件的节点流，用于读取/写入二进制文件（如图片、视频）或文本文件（需手动处理编码）。

核心方法：

FileInputStream：
- int read()：读1个字节，返回字节值（0-255），读到末尾返回-1；
- read(byte[] buffer)：读多个字节到缓冲区，返回实际读取的字节数，末尾返回-1（推荐，效率高于单个读）。
FileOutputStream：
- write(int b)：写1个字节（只取int的低8位）；
- write(byte[] buffer)：写缓冲区的所有字节；
- write(byte[] buffer, int off, int len)：写缓冲区从off开始的len个字节。

代码示例：用字节流复制图片（核心面试题）

import java.io.*;/*** 用FileInputStream+FileOutputStream复制图片* 面试注意：字节流可复制任意文件，字符流不能复制非文本文件（会损坏）*/
public class FileCopyDemo {public static void main(String[] args) {// 1. 定义源文件和目标文件路径String sourcePath = "D:/test.jpg";String targetPath = "D:/test_copy.jpg";// 2. 声明流对象（try-with-resources外声明，便于关闭）InputStream fis = null;OutputStream fos = null;try {// 3. 实例化流（节点流直接对接文件）fis = new FileInputStream(sourcePath);fos = new FileOutputStream(targetPath); // 若目标文件不存在，会自动创建// 4. 定义缓冲区（减少IO次数，提高效率）byte[] buffer = new byte[1024 * 8]; // 8KB缓冲区int len; // 记录每次实际读取的字节数// 5. 循环读取并写入while ((len = fis.read(buffer)) != -1) {// 注意：必须写len个字节，避免最后一次读取的缓冲区有残留数据fos.write(buffer, 0, len);}System.out.println("图片复制成功！");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {// 6. 关闭流（必须关闭，释放系统资源）// 注意：先关输出流，再关输入流；分别try-catch避免一个关闭失败影响另一个if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

面试高频问题：

为什么要用byte[] buffer？答：减少“用户态→内核态”的切换次数（IO操作是内核态），单个字节读效率极低，缓冲区越大效率越高（但不宜过大，避免内存浪费）。
为什么write时要传0和len？答：最后一次读取时，缓冲区可能未填满，若写整个缓冲区会包含垃圾数据，导致文件损坏。

（2）BufferedInputStream & BufferedOutputStream：缓冲字节流

处理流，包装节点流后提供“内部缓冲区”（默认8KB），无需手动定义缓冲区，进一步提高读写效率。

核心原理：

读数据时：先从数据源读入缓冲区，程序从缓冲区取数据，缓冲区空了再读数据源；
写数据时：先写入缓冲区，缓冲区满了再一次性写入数据源（可调用flush()强制刷新缓冲区）。

代码示例：用缓冲字节流优化文件复制

public class BufferedCopyDemo {public static void main(String[] args) {String sourcePath = "D:/test.mp4";String targetPath = "D:/test_copy.mp4";// JDK7+ 推荐：try-with-resources 自动关闭流（实现AutoCloseable接口的类均可）try (// 包装节点流：缓冲流增强功能InputStream bis = new BufferedInputStream(new FileInputStream(sourcePath));OutputStream bos = new BufferedOutputStream(new FileOutputStream(targetPath))) {byte[] buffer = new byte[1024 * 8];int len;while ((len = bis.read(buffer)) != -1) {bos.write(buffer, 0, len);// 无需手动flush()：close()时会自动刷新，或缓冲区满了自动刷新}System.out.println("视频复制成功（缓冲流优化）！");} catch (IOException e) {e.printStackTrace();}// 无需手动close()：try-with-resources会自动关闭，且关闭顺序是“先关外层处理流，再关内层节点流”}
}

面试考点：

缓冲流的效率为什么比节点流高？答：减少了实际的IO操作次数（缓冲区批量读写）；
flush()的作用？答：强制将缓冲区中的数据写入数据源（如网络传输中，需即时发送数据时调用，避免数据滞留）。

2.2 字符流：专门处理文本数据

字符流是“字节流+编码”的封装，核心解决文本数据的“中文乱码”问题。常用流包括FileReader/FileWriter（简单文本）、BufferedReader/BufferedWriter（缓冲+按行读）、InputStreamReader/OutputStreamWriter（字节→字符转换，核心）。

（1）InputStreamReader & OutputStreamWriter：转换流（核心面试点）

处理流，是字节流与字符流的桥梁——将字节流按指定编码转换为字符流，解决文本读写的中文乱码问题。

为什么需要转换流？
文本文件本质是字节序列，但不同编码（UTF-8、GBK）对中文的字节映射不同（如“中”在UTF-8中是3个字节，在GBK中是2个字节）。若直接用字节流读文本，需手动转换编码，容易出错；转换流则自动完成“字节→字符”的编码映射。

核心构造方法：

InputStreamReader(InputStream in, String charsetName)：字节输入流→字符输入流，指定编码（如“UTF-8”）；
OutputStreamWriter(OutputStream out, String charsetName)：字符输出流→字节输出流，指定编码。

代码示例：用转换流按UTF-8读写文本（解决乱码）

public class ConvertStreamDemo {public static void main(String[] args) {String filePath = "D:/test.txt";// 1. 写文本（指定UTF-8编码）try (// 字节输出流→转换流（指定UTF-8）Writer osw = new OutputStreamWriter(new FileOutputStream(filePath), "UTF-8");// 再包装缓冲流（按行写更方便）BufferedWriter bw = new BufferedWriter(osw)) {bw.write("Java IO流");bw.newLine(); // 换行（跨平台兼容，比"\n"好）bw.write("转换流解决中文乱码");bw.flush(); // 强制刷新（缓冲流写文本时，建议手动flush()）System.out.println("文本写入成功！");} catch (IOException e) {e.printStackTrace();}// 2. 读文本（必须与写入编码一致，否则乱码）try (// 字节输入流→转换流（指定UTF-8）Reader isr = new InputStreamReader(new FileInputStream(filePath), "UTF-8");// 包装缓冲流（支持按行读）BufferedReader br = new BufferedReader(isr)) {String line;// 按行读（readLine()返回null表示末尾）while ((line = br.readLine()) != null) {System.out.println("读取到：" + line);}} catch (IOException e) {e.printStackTrace();}}
}

面试高频问题：如何解决Java IO中的中文乱码？
答：核心是“读写编码一致”，具体方案：

用转换流InputStreamReader/OutputStreamWriter，明确指定编码（如UTF-8）；
避免使用FileReader/FileWriter（它们默认使用系统编码，跨平台易乱码）；
读写文本时优先用缓冲字符流（BufferedReader/BufferedWriter），支持按行操作。

（2）BufferedReader & BufferedWriter：缓冲字符流

处理流，包装字符流后提供“按行读写”功能（readLine()/newLine()），是处理文本文件的“首选”。

核心优势：

BufferedReader.readLine()：一次读取一整行文本（不含换行符），比read(char[])更方便；
BufferedWriter.newLine()：跨平台换行（Windows是\r\n，Linux是\n，自动适配）。

代码示例：用缓冲字符流复制文本文件

public class BufferedCharCopyDemo {public static void main(String[] args) {String source = "D:/source.txt";String target = "D:/target.txt";try (// 字节流→转换流（UTF-8）→缓冲流BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(source), "UTF-8"));BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(target), "UTF-8"))) {String line;while ((line = br.readLine()) != null) {bw.write(line); // 写一行文本bw.newLine(); // 换行}System.out.println("文本复制成功！");} catch (IOException e) {e.printStackTrace();}}
}

2.3 对象流：序列化与反序列化（面试重点）

对象流ObjectInputStream/ObjectOutputStream是处理流，用于将“Java对象”转换为字节序列（序列化），或从字节序列恢复为Java对象（反序列化）——核心解决“对象持久化”和“网络传输”问题。

（1）序列化的核心条件

一个对象要能被序列化，必须满足2个条件（面试必问）：

类必须实现java.io.Serializable接口（标记接口，无任何抽象方法，仅作标记）；
类中所有非静态（non-static）、非瞬态（non-transient）的成员变量都会被序列化。

（2）核心API与示例

ObjectOutputStream.writeObject(Object obj)：序列化对象；
ObjectInputStream.readObject()：反序列化对象（返回Object，需强转）。

代码示例：对象序列化与反序列化

import java.io.*;
import java.util.Date;// 1. 实现Serializable接口（标记为可序列化）
class User implements Serializable {// 2. 建议显式声明serialVersionUID（避免类结构变化导致反序列化失败）private static final long serialVersionUID = 1L;private String username;private transient String password; // transient：瞬态变量，不参与序列化private int age;private Date registerTime; // Date已实现Serializable，可序列化// 构造方法、getter/setterpublic User(String username, String password, int age) {this.username = username;this.password = password;this.age = age;this.registerTime = new Date();}@Overridepublic String toString() {return "User{" +"username='" + username + '\'' +", password='" + password + '\'' + // 反序列化后为null", age=" + age +", registerTime=" + registerTime +'}';}
}public class ObjectStreamDemo {public static void main(String[] args) {String filePath = "D:/user.obj";// 1. 序列化：将User对象写入文件try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {User user = new User("zhangsan", "123456", 20);oos.writeObject(user); // 序列化对象System.out.println("对象序列化成功！");} catch (IOException e) {e.printStackTrace();}// 2. 反序列化：从文件恢复User对象try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))) {User user = (User) ois.readObject(); // 反序列化，强转类型System.out.println("反序列化得到：" + user);} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}
}

输出结果：

对象序列化成功！
反序列化得到：User{username='zhangsan', password='null', age=20, registerTime=Wed Sep 01 15:30:00 CST 2025}

（3）面试高频考点：序列化的注意事项

serialVersionUID的作用？
答：用于验证序列化与反序列化的类版本一致性。若序列化时类的serialVersionUID与反序列化时不一致（如类新增/删除字段且未显式声明），会抛出InvalidClassException。建议显式声明，避免默认生成（默认值由类结构计算，易变）。
transient关键字的作用？
答：标记“瞬态变量”，不参与序列化（反序列化后为默认值，如null、0）。常用于敏感字段（如密码），避免序列化泄露。
静态变量会被序列化吗？
答：不会。静态变量属于类，不属于对象，序列化仅针对对象的实例数据。
哪些类型不能被序列化？
答：未实现Serializable的类（如Thread、InputStream）、匿名内部类（无serialVersionUID）、瞬态变量。

三、IO流面试高频问题汇总（附标准答案）

结合前文知识点，整理面试中最常问的10个问题，帮你直击考点。

1. 字节流和字符流的区别是什么？

维度	字节流	字符流
数据单位	字节（8位）	字符（16位）
处理数据类型	所有类型（文本、图片、视频）	仅文本类型
编码依赖	无	有（需指定编码，如UTF-8）
核心抽象类	InputStream/OutputStream	Reader/Writer
适用场景	复制文件、网络传输	读写文本文件、处理中文

一句话总结：字节流是“万能流”，字符流是“文本专用流”，中文处理优先用字符流。

2. 什么是节点流？什么是处理流？它们的关系是什么？

节点流：直接对接数据源，是IO的基础（如FileInputStream读文件）；
处理流：包装节点流/其他处理流，增强功能（如缓冲、转换、序列化）；
关系：处理流依赖节点流，通过“装饰器模式”动态扩展功能（面试可提设计模式，加分）。

3. 为什么要关闭流？如何正确关闭流？

关闭原因：流操作会占用系统资源（如文件句柄、网络连接），不关闭会导致资源泄露，最终耗尽系统资源。
正确关闭方式：
1. JDK7之前：用finally块关闭，先关外层处理流，再关内层节点流，且分别try-catch（避免一个关闭失败影响另一个）；
2. JDK7之后：优先用try-with-resources（自动关闭实现AutoCloseable接口的流，代码更简洁，且关闭顺序正确）。