前言

有人曾問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類使用實體

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

待續…