前言有人曾問fastjson的作者(阿里技術專家高鐵)：“你開發fastjson，沒得到什么好處，反而挨了罵背了鍋，這種事情你為什么要做呢？”

高鐵答道：“因為熱愛本身，就是獎勵啊！”

這個回答頓時觸動了我。想想自己，又何嘗不是如此。

IO流是Java中的一個重要構成部分，也是我們經常打交道的。

下面幾個問題(問題還會繼續補充)，如果你能對答如流，那么恭喜你，IO知識掌握得很好，可以立即關閉文章。反之，你可以在后面得文章中尋找答案。Java IO流有什么特點？

Java IO流分為幾種類型？

字節流和字符流的關系與區別？

字符流是否使用了緩沖？

緩沖流的效率一定高嗎？為什么？

緩沖流體現了Java中的哪種設計模式思想？

為什么要實現序列化?如何實現序列化?

序列化數據后，再次修改類文件，讀取數據會出問題，如何解決呢?

1 初識Java IO

IO，即in和out，也就是輸入和輸出，指應用程序和外部設備之間的數據傳遞，常見的外部設備包括文件、管道、網絡連接。

Java 中是通過流處理IO 的，那么什么是流？

流(Stream)，是一個抽象的概念，是指一連串的數據(字符或字節)，是以先進先出的方式發送信息的通道。

當程序需要讀取數據的時候，就會開啟一個通向數據源的流，這個數據源可以是文件，內存，或是網絡連接。類似的，當程序需要寫入數據的時候，就會開啟一個通向目的地的流。這時候你就可以想象數據好像在這其中“流”動一樣。

一般來說關于流的特性有下面幾點：先進先出：最先寫入輸出流的數據最先被輸入流讀取到。

順序存取：可以一個接一個地往流中寫入一串字節，讀出時也將按寫入順序讀取一串字節，不能隨機訪問中間的數據。(RandomAccessFile除外)

只讀或只寫：每個流只能是輸入流或輸出流的一種，不能同時具備兩個功能，輸入流只能進行讀操作，對輸出流只能進行寫操作。在一個數據傳輸通道中，如果既要寫入數據，又要讀取數據，則要分別提供兩個流。

1.1 IO流分類

IO流主要的分類方式有以下3種：按數據流的方向：輸入流、輸出流

按處理數據單位：字節流、字符流

按功能：節點流、處理流

1、輸入流與輸出流

輸入與輸出是相對于應用程序而言的，比如文件讀寫，讀取文件是輸入流，寫文件是輸出流，這點很容易搞反。

2、字節流與字符流

字節流和字符流的用法幾乎完成全一樣，區別在于字節流和字符流所操作的數據單元不同，字節流操作的單元是數據單元是8位的字節，字符流操作的是數據單元為16位的字符。

為什么要有字符流？

Java中字符是采用Unicode標準，Unicode 編碼中，一個英文為一個字節，一個中文為兩個字節。

而在UTF-8編碼中，一個中文字符是3個字節。例如下面圖中，“云深不知處”5個中文對應的是15個字節：-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124

那么問題來了，如果使用字節流處理中文，如果一次讀寫一個字符對應的字節數就不會有問題，一旦將一個字符對應的字節分裂開來，就會出現亂碼了。為了更方便地處理中文這些字符，Java就推出了字符流。

字節流和字符流的其他區別：字節流一般用來處理圖像、視頻、音頻、PPT、Word等類型的文件。字符流一般用于處理純文本類型的文件，如TXT文件等，但不能處理圖像視頻等非文本文件。用一句話說就是：字節流可以處理一切文件，而字符流只能處理純文本文件。

字節流本身沒有緩沖區，緩沖字節流相對于字節流，效率提升非常高。而字符流本身就帶有緩沖區，緩沖字符流相對于字符流效率提升就不是那么大了。詳見文末效率對比。

以寫文件為例，我們查看字符流的源碼，發現確實有利用到緩沖區：

3、節點流和處理流

節點流：直接操作數據讀寫的流類，比如FileInputStream

處理流：對一個已存在的流的鏈接和封裝，通過對數據進行處理為程序提供功能強大、靈活的讀寫功能，例如BufferedInputStream(緩沖字節流)

處理流和節點流應用了Java的裝飾者設計模式。

下圖就很形象地描繪了節點流和處理流，處理流是對節點流的封裝，最終的數據處理還是由節點流完成的。

在諸多處理流中，有一個非常重要，那就是緩沖流。

我們知道，程序與磁盤的交互相對于內存運算是很慢的，容易成為程序的性能瓶頸。減少程序與磁盤的交互，是提升程序效率一種有效手段。緩沖流，就應用這種思路：普通流每次讀寫一個字節，而緩沖流在內存中設置一個緩存區，緩沖區先存儲足夠的待操作數據后，再與內存或磁盤進行交互。這樣，在總數據量不變的情況下，通過提高每次交互的數據量，減少了交互次數。

聯想一下生活中的例子，我們搬磚的時候，一塊一塊地往車上裝肯定是很低效的。我們可以使用一個小推車，先把磚裝到小推車上，再把這小推車推到車前，把磚裝到車上。這個例子中，小推車可以視為緩沖區，小推車的存在，減少了我們裝車次數，從而提高了效率。

需要注意的是，緩沖流效率一定高嗎？不一定，某些情形下，緩沖流效率反而更低，具體請見IO流效率對比。

完整的IO分類圖如下：

1.2 案例實操

接下來，我們看看如何使用Java IO。

文本讀寫的例子，也就是文章開頭所說的，將“松下問童子，言師采藥去。只在此山中，云深不知處。”寫入本地文本，然后再從文件讀取內容并輸出到控制臺。

1、FileInputStream、FileOutputStream(字節流)字節流的方式效率較低，不建議使用

public class IOTest {

public static void main(String[] args) throws IOException {

File file = new File("D:/test.txt");

write(file);

System.out.println(read(file));

}

public static void write(File file) throws IOException {

OutputStream os = new FileOutputStream(file, true);

// 要寫入的字符串

String string = "松下問童子，言師采藥去。只在此山中，云深不知處。";

// 寫入文件

os.write(string.getBytes());

// 關閉流

os.close();

}

public static String read(File file) throws IOException {

InputStream in = new FileInputStream(file);

// 一次性取多少個字節

byte[] bytes = new byte[1024];

// 用來接收讀取的字節數組

StringBuilder sb = new StringBuilder();

// 讀取到的字節數組長度，為-1時表示沒有數據

int length = 0;

// 循環取數據

while ((length = in.read(bytes)) != -1) {

// 將讀取的內容轉換成字符串

sb.append(new String(bytes, 0, length));

}

// 關閉流

in.close();

return sb.toString();

}

}

2、BufferedInputStream、BufferedOutputStream(緩沖字節流)緩沖字節流是為高效率而設計的，真正的讀寫操作還是靠FileOutputStream和FileInputStream，所以其構造方法入參是這兩個類的對象也就不奇怪了。

public class IOTest {

public static void write(File file) throws IOException {

// 緩沖字節流，提高了效率

BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));

// 要寫入的字符串

String string = "松下問童子，言師采藥去。只在此山中，云深不知處。";

// 寫入文件

bis.write(string.getBytes());

// 關閉流

bis.close();

}

public static String read(File file) throws IOException {

BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));

// 一次性取多少個字節

byte[] bytes = new byte[1024];

// 用來接收讀取的字節數組

StringBuilder sb = new StringBuilder();

// 讀取到的字節數組長度，為-1時表示沒有數據

int length = 0;

// 循環取數據

while ((length = fis.read(bytes)) != -1) {

// 將讀取的內容轉換成字符串

sb.append(new String(bytes, 0, length));

}

// 關閉流

fis.close();

return sb.toString();

}

}

3、InputStreamReader、OutputStreamWriter(字符流)字符流適用于文本文件的讀寫，OutputStreamWriter類其實也是借助FileOutputStream類實現的，故其構造方法是FileOutputStream的對象

public class IOTest {

public static void write(File file) throws IOException {

// OutputStreamWriter可以顯示指定字符集，否則使用默認字符集

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");

// 要寫入的字符串

String string = "松下問童子，言師采藥去。只在此山中，云深不知處。";

osw.write(string);

osw.close();

}

public static String read(File file) throws IOException {

InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");

// 字符數組：一次讀取多少個字符

char[] chars = new char[1024];

// 每次讀取的字符數組先append到StringBuilder中

StringBuilder sb = new StringBuilder();

// 讀取到的字符數組長度，為-1時表示沒有數據

int length;

// 循環取數據

while ((length = isr.read(chars)) != -1) {

// 將讀取的內容轉換成字符串

sb.append(chars, 0, length);

}

// 關閉流

isr.close();

return sb.toString()

}

}

4、字符流便捷類Java提供了FileWriter和FileReader簡化字符流的讀寫，new FileWriter等同于new OutputStreamWriter(new FileOutputStream(file, true))

public class IOTest {

public static void write(File file) throws IOException {

FileWriter fw = new FileWriter(file, true);

// 要寫入的字符串

String string = "松下問童子，言師采藥去。只在此山中，云深不知處。";

fw.write(string);

fw.close();

}

public static String read(File file) throws IOException {

FileReader fr = new FileReader(file);

// 一次性取多少個字節

char[] chars = new char[1024];

// 用來接收讀取的字節數組

StringBuilder sb = new StringBuilder();

// 讀取到的字節數組長度，為-1時表示沒有數據

int length;

// 循環取數據

while ((length = fr.read(chars)) != -1) {

// 將讀取的內容轉換成字符串

sb.append(chars, 0, length);

}

// 關閉流

fr.close();

return sb.toString();

}

}

5、BufferedReader、BufferedWriter(字符緩沖流)

public class IOTest {

public static void write(File file) throws IOException {

// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new

// FileOutputStream(file, true), "UTF-8"));

// FileWriter可以大幅度簡化代碼

BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));

// 要寫入的字符串

String string = "松下問童子，言師采藥去。只在此山中，云深不知處。";

bw.write(string);

bw.close();

}

public static String read(File file) throws IOException {

BufferedReader br = new BufferedReader(new FileReader(file));

// 用來接收讀取的字節數組

StringBuilder sb = new StringBuilder();

// 按行讀數據

String line;

// 循環取數據

while ((line = br.readLine()) != null) {

// 將讀取的內容轉換成字符串

sb.append(line);

}

// 關閉流

br.close();

return sb.toString();

}

}

2 IO流對象

第一節中，我們大致了解了IO，并完成了幾個案例，但對IO還缺乏更詳細的認知，那么接下來我們就對Java IO細細分解，梳理出完整的知識體系來。

Java種提供了40多個類，我們只需要詳細了解一下其中比較重要的就可以滿足日常應用了。

2.1 File類

File類是用來操作文件的類，但它不能操作文件中的數據。

public class File extends Object implements Serializable, Comparable

File類實現了Serializable、 Comparable，說明它是支持序列化和排序的。

File類的構造方法

File類的常用方法

File類使用實例

public class FileTest {

public static void main(String[] args) throws IOException {

File file = new File("C:/Mu/fileTest.txt");

// 判斷文件是否存在

if (!file.exists()) {

// 不存在則創建

file.createNewFile();

}

System.out.println("文件的絕對路徑：" + file.getAbsolutePath());

System.out.println("文件的大小：" + file.length());

// 刪除文件

file.delete();

}

}

2.2 字節流

InputStream與OutputStream是兩個抽象類，是字節流的基類，所有具體的字節流實現類都是分別繼承了這兩個類。

以InputStream為例，它繼承了Object，實現了Closeable

public abstract class InputStream

extends Object

implements Closeable

InputStream類有很多的實現子類，下面列舉了一些比較常用的：

詳細說明一下上圖中的類：InputStream：InputStream是所有字節輸入流的抽象基類，前面說過抽象類不能被實例化，實際上是作為模板而存在的，為所有實現類定義了處理輸入流的方法。

FileInputSream：文件輸入流，一個非常重要的字節輸入流，用于對文件進行讀取操作。

PipedInputStream：管道字節輸入流，能實現多線程間的管道通信。

ByteArrayInputStream：字節數組輸入流，從字節數組(byte[])中進行以字節為單位的讀取，也就是將資源文件都以字節的形式存入到該類中的字節數組中去。

FilterInputStream：裝飾者類，具體的裝飾者繼承該類，這些類都是處理類，作用是對節點類進行封裝，實現一些特殊功能。

DataInputStream：數據輸入流，它是用來裝飾其它輸入流，作用是“允許應用程序以與機器無關方式從底層輸入流中讀取基本 Java 數據類型”。

BufferedInputStream：緩沖流，對節點流進行裝飾，內部會有一個緩存區，用來存放字節，每次都是將緩存區存滿然后發送，而不是一個字節或兩個字節這樣發送，效率更高。

ObjectInputStream：對象輸入流，用來提供對基本數據或對象的持久存儲。通俗點說，也就是能直接傳輸對象，通常應用在反序列化中。它也是一種處理流，構造器的入參是一個InputStream的實例對象。

OutputStream類繼承關系圖：

OutputStream類繼承關系與InputStream類似，需要注意的是PrintStream.

2.3 字符流

與字節流類似，字符流也有兩個抽象基類，分別是Reader和Writer。其他的字符流實現類都是繼承了這兩個類。

以Reader為例，它的主要實現子類如下圖：

各個類的詳細說明：InputStreamReader：從字節流到字符流的橋梁(InputStreamReader構造器入參是FileInputStream的實例對象)，它讀取字節并使用指定的字符集將其解碼為字符。它使用的字符集可以通過名稱指定，也可以顯式給定，或者可以接受平臺的默認字符集。

BufferedReader：從字符輸入流中讀取文本，設置一個緩沖區來提高效率。BufferedReader是對InputStreamReader的封裝，前者構造器的入參就是后者的一個實例對象。

FileReader：用于讀取字符文件的便利類，new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8")，但FileReader不能指定字符編碼和默認字節緩沖區大小。

PipedReader ：管道字符輸入流。實現多線程間的管道通信。

CharArrayReader：從Char數組中讀取數據的介質流。

StringReader ：從String中讀取數據的介質流。

Writer與Reader結構類似，方向相反，不再贅述。唯一有區別的是，Writer的子類PrintWriter。

2.4 序列化

待續…

3 IO流方法

3.1 字節流方法

字節輸入流InputStream主要方法：read() ：從此輸入流中讀取一個數據字節。

read(byte[] b) ：從此輸入流中將最多 b.length 個字節的數據讀入一個 byte 數組中。

read(byte[] b, int off, int len) ：從此輸入流中將最多 len 個字節的數據讀入一個 byte 數組中。

close()：關閉此輸入流并釋放與該流關聯的所有系統資源。

字節輸出流OutputStream主要方法：write(byte[] b) ：將 b.length 個字節從指定 byte 數組寫入此文件輸出流中。

write(byte[] b, int off, int len) ：將指定 byte 數組中從偏移量 off 開始的 len 個字節寫入此文件輸出流。

write(int b) ：將指定字節寫入此文件輸出流。

close() ：關閉此輸入流并釋放與該流關聯的所有系統資源。

3.2 字符流方法

字符輸入流Reader主要方法：read()：讀取單個字符。

read(char[] cbuf) ：將字符讀入數組。

read(char[] cbuf, int off, int len) ： 將字符讀入數組的某一部分。

read(CharBuffer target) ：試圖將字符讀入指定的字符緩沖區。

flush() ：刷新該流的緩沖。

close() ：關閉此流，但要先刷新它。

字符輸出流Writer主要方法：write(char[] cbuf) ：寫入字符數組。

write(char[] cbuf, int off, int len) ：寫入字符數組的某一部分。

write(int c) ：寫入單個字符。

write(String str) ：寫入字符串。

write(String str, int off, int len) ：寫入字符串的某一部分。

flush() ：刷新該流的緩沖。

close() ：關閉此流，但要先刷新它。

另外，字符緩沖流還有兩個獨特的方法：BufferedWriter類newLine() ：寫入一個行分隔符。這個方法會自動適配所在系統的行分隔符。

BufferedReader類readLine() ：讀取一個文本行。

4 附加內容

4.1 位、字節、字符

字節(Byte)是計量單位，表示數據量多少，是計算機信息技術用于計量存儲容量的一種計量單位，通常情況下一字節等于八位。

字符(Character)計算機中使用的字母、數字、字和符號，比如’A’、‘B’、’$’、’&'等。

一般在英文狀態下一個字母或字符占用一個字節，一個漢字用兩個字節表示。

字節與字符：ASCII 碼中，一個英文字母(不分大小寫)為一個字節，一個中文漢字為兩個字節。

UTF-8 編碼中，一個英文字為一個字節，一個中文為三個字節。

Unicode 編碼中，一個英文為一個字節，一個中文為兩個字節。

符號：英文標點為一個字節，中文標點為兩個字節。例如：英文句號 . 占1個字節的大小，中文句號 。占2個字節的大小。

UTF-16 編碼中，一個英文字母字符或一個漢字字符存儲都需要 2 個字節(Unicode 擴展區的一些漢字存儲需要 4 個字節)。

UTF-32 編碼中，世界上任何字符的存儲都需要 4 個字節。

4.2 IO流效率對比

首先，對比下普通字節流和緩沖字節流的效率：

public class MyTest {

public static void main(String[] args) throws IOException {

File file = new File("C:/Mu/test.txt");

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 3000000; i++) {

sb.append("abcdefghigklmnopqrstuvwsyz");

}

byte[] bytes = sb.toString().getBytes();

long start = System.currentTimeMillis();

write(file, bytes);

long end = System.currentTimeMillis();

long start2 = System.currentTimeMillis();

bufferedWrite(file, bytes);

long end2 = System.currentTimeMillis();

System.out.println("普通字節流耗時：" + (end - start) + " ms");

System.out.println("緩沖字節流耗時：" + (end2 - start2) + " ms");

}

// 普通字節流

public static void write(File file, byte[] bytes) throws IOException {

OutputStream os = new FileOutputStream(file);

os.write(bytes);

os.close();

}

// 緩沖字節流

public static void bufferedWrite(File file, byte[] bytes) throws IOException {

BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file));

bo.write(bytes);

bo.close();

}

}

運行結果：

普通字節流耗時：250 ms

緩沖字節流耗時：268 ms

這個結果讓我大跌眼鏡，不是說好緩沖流效率很高么？要知道為什么，只能去源碼里找答案了。翻看字節緩沖流的write方法：

public synchronized void write(byte b[], int off, int len) throws IOException {

if (len >= buf.length) {

/* If the request length exceeds the size of the output buffer,

flush the output buffer and then write the data directly.

In this way buffered streams will cascade harmlessly. */

flushBuffer();

out.write(b, off, len);

return;

}

if (len > buf.length - count) {

flushBuffer();

}

System.arraycopy(b, off, buf, count, len);

count += len;

}

注釋里說得很明白：如果請求長度超過輸出緩沖區的大小，刷新輸出緩沖區，然后直接寫入數據。這樣，緩沖流將無害地級聯。

但是，至于為什么這么設計，我沒有想明白，有哪位明白的大佬可以留言指點一下。

基于上面的情形，要想對比普通字節流和緩沖字節流的效率差距，就要避免直接讀寫較長的字符串，于是，設計了下面這個對比案例：用字節流和緩沖字節流分別復制文件。

public class MyTest {

public static void main(String[] args) throws IOException {

File data = new File("C:/Mu/data.zip");

File a = new File("C:/Mu/a.zip");

File b = new File("C:/Mu/b.zip");

StringBuilder sb = new StringBuilder();

long start = System.currentTimeMillis();

copy(data, a);

long end = System.currentTimeMillis();

long start2 = System.currentTimeMillis();

bufferedCopy(data, b);

long end2 = System.currentTimeMillis();

System.out.println("普通字節流耗時：" + (end - start) + " ms");

System.out.println("緩沖字節流耗時：" + (end2 - start2) + " ms");

}

// 普通字節流

public static void copy(File in, File out) throws IOException {

// 封裝數據源

InputStream is = new FileInputStream(in);

// 封裝目的地

OutputStream os = new FileOutputStream(out);

int by = 0;

while ((by = is.read()) != -1) {

os.write(by);

}

is.close();

os.close();

}

// 緩沖字節流

public static void bufferedCopy(File in, File out) throws IOException {

// 封裝數據源

BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in));

// 封裝目的地

BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out));

int by = 0;

while ((by = bi.read()) != -1) {

bo.write(by);

}

bo.close();

bi.close();

}

}

運行結果：

普通字節流耗時：184867 ms

緩沖字節流耗時：752 ms

這次，普通字節流和緩沖字節流的效率差異就很明顯了，達到了245倍。

再看看字符流和緩沖字符流的效率對比：

public class IOTest {

public static void main(String[] args) throws IOException {

// 數據準備

dataReady();

File data = new File("C:/Mu/data.txt");

File a = new File("C:/Mu/a.txt");

File b = new File("C:/Mu/b.txt");

File c = new File("C:/Mu/c.txt");

long start = System.currentTimeMillis();

copy(data, a);

long end = System.currentTimeMillis();

long start2 = System.currentTimeMillis();

copyChars(data, b);

long end2 = System.currentTimeMillis();

long start3 = System.currentTimeMillis();

bufferedCopy(data, c);

long end3 = System.currentTimeMillis();

System.out.println("普通字節流1耗時：" + (end - start) + " ms,文件大小：" + a.length() / 1024 + " kb");

System.out.println("普通字節流2耗時：" + (end2 - start2) + " ms,文件大小：" + b.length() / 1024 + " kb");

System.out.println("緩沖字節流耗時：" + (end3 - start3) + " ms,文件大小：" + c.length() / 1024 + " kb");

}

// 普通字符流不使用數組

public static void copy(File in, File out) throws IOException {

Reader reader = new FileReader(in);

Writer writer = new FileWriter(out);

int ch = 0;

while ((ch = reader.read()) != -1) {

writer.write((char) ch);

}

reader.close();

writer.close();

}

// 普通字符流使用字符流

public static void copyChars(File in, File out) throws IOException {

Reader reader = new FileReader(in);

Writer writer = new FileWriter(out);

char[] chs = new char[1024];

while ((reader.read(chs)) != -1) {

writer.write(chs);

}

reader.close();

writer.close();

}

// 緩沖字符流

public static void bufferedCopy(File in, File out) throws IOException {

BufferedReader br = new BufferedReader(new FileReader(in));

BufferedWriter bw = new BufferedWriter(new FileWriter(out));

String line = null;

while ((line = br.readLine()) != null) {

bw.write(line);

bw.newLine();

bw.flush();

}

// 釋放資源

bw.close();

br.close();

}

// 數據準備

public static void dataReady() throws IOException {

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 600000; i++) {

sb.append("abcdefghijklmnopqrstuvwxyz");

}

OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt"));

os.write(sb.toString().getBytes());

os.close();

System.out.println("完畢");

}

}

運行結果：

普通字符流1耗時：1337 ms,文件大小：15234 kb

普通字符流2耗時：82 ms,文件大小：15235 kb

緩沖字符流耗時：205 ms,文件大小：15234 kb

測試多次，結果差不多，可見字符緩沖流效率上并沒有明顯提高，我們更多的是要使用它的readLine()和newLine()方法。

總結

以上是生活随笔為你收集整理的java byte char io流_吃透Java IO：字节流、字符流、缓冲流的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。