前言

有人曾問fastjson的作者（阿里技術專家高鐵）：「你開發fastjson，沒得到什麼好處，反而捱了罵背了鍋，這種事情你為什麼要做呢？」

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

這個回答頓時觸動了我。想想自己，又何嘗不是如此。寫作是個痛苦的過程，用心寫作就更加煎熬，需字字斟酌，反覆刪改才有所成。然而，當一篇篇精良文章出自己手而呈現眼前時，那些痛苦煎熬就都那麼值得。如果這些博文能有幸得大家閱讀和認可，就更加是莫大的鼓舞了。技術人的快樂就是可以這麼純粹和簡單。

如果各位能順手點個贊，就更好了(●’◡’●)。

IO流是Java中的一個重要構成部分，也是我們經常打交道的。這篇關於Java IO的博文乾貨滿滿，堪稱全網前三（請輕噴！）

下面幾個問題（問題還會繼續補充），如果你能對答如流，那麼恭喜你，IO知識掌握得很好，可以立即關閉文章。反之，你可以在後面得文章中尋找答案。

1. Java IO流有什麼特點？
2. Java IO流分為幾種型別？
3. 位元組流和字元流的關係與區別？
4. 字元流是否使用了緩衝？
5. 緩衝流的效率一定高嗎？為什麼？
6. 緩衝流體現了Java中的哪種設計模式思想？
7. 為什麼要實現序列化?如何實現序列化?
8. 序列化資料後，再次修改類檔案，讀取資料會出問題，如何解決呢?

1 初識Java IO

IO，即in和out，也就是輸入和輸出，指應用程式和外部裝置之間的資料傳遞，常見的外部裝置包括檔案、管道、網路連線。

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

流（Stream），是一個抽象的概念，是指一連串的資料（字元或位元組），是以先進先出的方式傳送資訊的通道。

當程式需要讀取資料的時候，就會開啟一個通向資料來源的流，這個資料來源可以是檔案，記憶體，或是網路連線。類似的，當程式需要寫入資料的時候，就會開啟一個通向目的地的流。這時候你就可以想象資料好像在這其中「流」動一樣。

一般來說關於流的特性有下面幾點：

1. 先進先出：最先寫入輸出流的資料最先被輸入流讀取到。
2. 順序存取：可以一個接一個地往流中寫入一串位元組，讀出時也將按寫入順序讀取一串位元組，不能隨機存取中間的資料。（RandomAccessFile除外）
3. 唯讀或只寫：每個流只能是輸入流或輸出流的一種，不能同時具備兩個功能，輸入流只能進行讀操作，對輸出流只能進行寫操作。在一個資料傳輸通道中，如果既要寫入資料，又要讀取資料，則要分別提供兩個流。

1.1 IO流分類

IO流主要的分類方式有以下3種：

1. 按資料流的方向：輸入流、輸出流
2. 按處理資料單位：位元組流、字元流
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就推出了字元流。

位元組流和字元流的其他區別：

1. 位元組流一般用來處理影象、視訊、音訊、PPT、Word等型別的檔案。字元流一般用於處理純文字型別的檔案，如TXT檔案等，但不能處理影象視訊等非文字檔案。用一句話說就是：位元組流可以處理一切檔案，而字元流只能處理純文字檔案。
2. 位元組流本身沒有緩衝區，緩衝位元組流相對於位元組流，效率提升非常高。而字元流本身就帶有緩衝區，緩衝字元流相對於字元流效率提升就不是那麼大了。詳見文末效率對比。

以寫檔案為例，我們檢視字元流的原始碼，發現確實有利用到緩衝區：

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>

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

File類的構造方法

方法名	說明
File(File parent, String child)	根據 parent 抽象路徑名和 child 路徑名字串建立一個新 File 範例。
File(String pathname)	通過將給定路徑名字串轉換為抽象路徑名來建立一個新 File 範例。
File(String parent, String child)	根據 parent 路徑名字串和 child 路徑名字串建立一個新 File 範例。
File(URI uri)	通過將給定的 file: URI 轉換為一個抽象路徑名來建立一個新的 File 範例。

File類的常用方法

方法	說明
createNewFile()	當且僅當不存在具有此抽象路徑名指定名稱的檔案時，不可分地建立一個新的空檔案。
delete()	刪除此抽象路徑名錶示的檔案或目錄。
exists()	測試此抽象路徑名錶示的檔案或目錄是否存在。
getAbsoluteFile()	返回此抽象路徑名的絕對路徑名形式。
getAbsolutePath()	返回此抽象路徑名的絕對路徑名字串。
length()	返回由此抽象路徑名錶示的檔案的長度。
mkdir()	建立此抽象路徑名指定的目錄。

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類有很多的實現子類，下面列舉了一些比較常用的：

詳細說明一下上圖中的類：

1. InputStream：InputStream是所有位元組輸入流的抽象基礎類別，前面說過抽象類不能被範例化，實際上是作為模板而存在的，為所有實現類定義了處理輸入流的方法。
2. FileInputSream：檔案輸入流，一個非常重要的位元組輸入流，用於對檔案進行讀取操作。
3. PipedInputStream：管道位元組輸入流，能實現多執行緒間的管道通訊。
4. ByteArrayInputStream：位元組陣列輸入流，從位元組陣列(byte[])中進行以位元組為單位的讀取，也就是將資原始檔都以位元組的形式存入到該類中的位元組陣列中去。
5. FilterInputStream：裝飾者類，具體的裝飾者繼承該類，這些類都是處理類，作用是對節點類進行封裝，實現一些特殊功能。
6. DataInputStream：資料輸入流，它是用來裝飾其它輸入流，作用是「允許應用程式以與機器無關方式從底層輸入流中讀取基本 Java 資料型別」。
7. BufferedInputStream：緩衝流，對節點流進行裝飾，內部會有一個快取區，用來存放位元組，每次都是將快取區存滿然後傳送，而不是一個位元組或兩個位元組這樣傳送，效率更高。
8. ObjectInputStream：物件輸入流，用來提供對基本資料或物件的持久儲存。通俗點說，也就是能直接傳輸物件，通常應用在反序列化中。它也是一種處理流，構造器的入參是一個InputStream的範例物件。

OutputStream類繼承關係圖：

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

2.3 字元流

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

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

各個類的詳細說明：

1. InputStreamReader：從位元組流到字元流的橋樑（InputStreamReader構造器入參是FileInputStream的範例物件），它讀取位元組並使用指定的字元集將其解碼為字元。它使用的字元集可以通過名稱指定，也可以顯式給定，或者可以接受平臺的預設字元集。
2. BufferedReader：從字元輸入流中讀取文字，設定一個緩衝區來提高效率。BufferedReader是對InputStreamReader的封裝，前者構造器的入參就是後者的一個範例物件。
3. FileReader：用於讀取字元檔案的便利類，new FileReader(File file)等同於new InputStreamReader(new FileInputStream(file, true),"UTF-8")，但FileReader不能指定字元編碼和預設位元組緩衝區大小。
4. PipedReader ：管道字元輸入流。實現多執行緒間的管道通訊。
5. CharArrayReader：從Char陣列中讀取資料的媒介流。
6. 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()方法。

4.3 NIO

待續…