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接口的流，代碼更簡潔，且關閉順序正確）。