總結一：
Java IO的一般使用原則：
一、按數據來源（去向）分類：
1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、網絡數據流：InputStream, OutputStream, Reader, Writer
二、按是否格式化輸出分：
1、要格式化輸出：PrintStream, PrintWriter
三、按是否要緩衝分：
1、要緩衝：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter
四、按數據格式分：
1、二進制格式（只要不能確定是純文本的）: InputStream, OutputStream及其所有帶Stream結束的子類
2、純文本格式（含純英文與漢字或其他編碼方式）；Reader, Writer及其所有帶Reader, Writer的子類
五、按輸入輸出分：
1、輸入：Reader, InputStream類型的子類
2、輸出：Writer, OutputStream類型的子類
六、特殊需要：
1、從Stream到Reader,Writer的轉換類：InputStreamReader, OutputStreamWriter
2、對象輸入輸出：ObjectInputStream, ObjectOutputStream
3、進程間通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4、合併輸入：SequenceInputStream
5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
決定使用哪個類以及它的構造進程的一般準則如下（不考慮特殊需要）：
第一，考慮最原始的數據格式是什麼：是否爲文本？
第二，是輸入還是輸出?
第三，是否需要轉換流：InputStreamReader, OutputStreamWriter?
第四，數據來源（去向）是什麼：文件？內存？網絡？
第五，是否要緩衝：bufferedReader （特別註明：一定要注意的是readLine()是否有定義，有什麼比read, write更特殊的輸入或輸出方法）
第六，是否要格式化輸出：print?
總結二：
首先是java的IO。這破東西可真費事，I/O類庫常使用”流(stream)”這種抽象。所謂”流”是一種能生成或接受數據的，代表數據的源和目標的對象。流把I/O設備內部的具體操作給隱藏起來了。 正如JDK文檔所顯示的，Java的I/O類庫分成輸入和輸出兩大部分。所有InputStream和Reader的派生類都有一個基本的，繼承下來的，能讀取單個或byte數組的read( )方法。同理，所有OutputStream和Writer的派生類都有一個基本的，能寫入單個或byte數組的write( )方法。但通常情況下，你是不會去用這些方法的；它們是給其它類用的 —— 而後者會提供一些更實用的接口。因此，你很少會碰到只用一個類就能創建一個流的情形，實際上你得把多個對象疊起來，並以此來獲取所需的功能。Java的流類庫之所以會那麼讓人犯暈，最主要的原因就是”你必須爲創建一個流而動用多個對象”。
Java的IO類結構：
根接口是InputStream/OutputStream，充當數據源的IO類有FileInputStream /FileOutputStream，ByteArrayInputStream / ByteArrayOutputStream 等，充當裝飾功能的IO類有BufferedInputStream / BufferedOutputStream，DataInputStream / DataOutputStream等，
它們都是繼承裝飾接口FilterInputStream/FilterOutputStream。
使用IO時，首先創建一個數據源IO，然後根據需要的功能創建裝飾類IO，其構造函數的參數爲已創建的數據源IO。
我們以創建一個具有緩衝的文件輸入流爲例，假定需要從磁盤讀取文件“C:\log.txt”：
// 創建一個FileInputStream:
FileInputStream fileInput = new FileInputStream(”C:\\log.txt”);
// 創建一個BufferedInputStream:
BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);
// 現在得到的bufferedInput即是具有緩衝的文件輸入流
或者進一步簡寫如下：
InputStream input = new BufferedInputStream(new FileInputStream(”C:\\log.txt”));
// 現在得到的input即是具有緩衝的文件輸入流
java.io.Reader 和 java.io.InputStream 區別
java.io.Reader 和 java.io.InputStream 組成了 Java 輸入類。Reader 用於讀入16位字符，也就是 Unicode 編碼的字符；而 InputStream 用於讀入 ASCII 字符和二進制數據。
在 Java 中，有不同類型的 Reader 輸入流對應於不同的數據源：
FileReader 用於從文件輸入；
CharArrayReader 用於從程序中的字符數組輸入；
StringReader 用於從程序中的字符串輸入；
PipedReader 用於讀取從另一個線程中的 PipedWriter 寫入管道的數據。
相 應的也有不同類型的 InputStream 輸入流對應於不同的數據 源：FileInputStream，ByteArrayInputStream，StringBufferInputStream，PipedInputStream。 另外，還有兩種沒有對應 Reader 類型的 InputStream 輸入流：
Socket 用於套接字；
URLConnection 用於 URL 連接。
這兩個類使用 getInputStream() 來讀取數據。
相應的，java.io.Writer 和 java.io.OutputStream 也有類似的區別。
1、Java技術支持兩種數據類型的流
InputStream和OutputStream：字節流。其它字節流都是InputStream或OutputStream的子類。
Reader和 Writer：字符流。其它字符流都是Reader或Writer的子類。
2、節點流
Java 2 SDK中有三種基本類型的節點：文件(file)、內存(memory)、管道(pipe)。
3、過程流
過程流在其它流之上，完成排序、變換等操作。過程流也被稱做過濾流。
當你需要改變輸入流的原始數據時，你可以將一個過濾輸入流連接到一個原始的輸入流上。
用過濾流將原始數據變換成你需要的格式。
4、基本字節流類
4.1、FileInputStream和FileOutputStream
這兩個節點流用來操縱磁盤文件。這些類的構造函數允許你指定它們所連接的文件。
要構造一個FileInputStream，所關聯的文件必須存在而且是可讀的。
如果你要構造一個FileOutputStream而輸出文件已經存在，則它將被覆蓋。
FileInputStream infile = new FileInputStream(”myfile.dat”);
FileOutputStream outfile = new FileOutputStream(”results.dat”);
4.1、 BufferInputStream和BufferOutputStream
這些是過濾器流，它們可以提高I/O操作的效率。
4.3、 PipedInputStream和PipedOutputStream
管道流用來在線程間進行通信。一個線程的PipedInputStream對象從另一個線程的PipedOutputStream對象讀取輸入。
要使管道流有用，必須有一個輸入方和一個輸出方。
4.4、 DataInputStream和DataOutputStream
這些過濾器通過流來讀寫Java基本類
5、 基本字符流類
圖闡述了Reader和Writer字符流的體系結構。
5.1、InputStreamReader 和 OutputStreamWriter
用於字節流與字符流之間的轉換接口。
當你構造一個InputStreamReader或OutputStreamWriter時，轉換規則定義了16位Unicode和其它平臺的特定表示之間的轉換。
InputStreamReader從一個數據源讀取字節，並自動將其轉換成Unicode字符。
如果你特別聲明，InputStreamReade會將字節流轉換成其它種類的字符流。
OutputStreamWriter將字符的Unicode編碼寫到輸出流，如果你的使用的不是Unicode字符，OutputStreamWriter會將你的字符編碼轉換成Unicode編碼。
5.2.、緩衝讀者和作者
因爲在各種格式之間進行轉換和其它I/O操作很類似，所以在處理大塊數據時效率最高。
在InputStreamReader和OutputStreamWriter的結尾鏈接一個BufferedReader和BufferedWriter是一個好主意。
記住對BufferedWriter使用flush()方法。
5.3、 使用其它字符轉換
如果你需要從一個非本地(例如，從連接到一個不同類型的機器的網絡連接讀取)的字符編碼讀取輸入，
你可以象下面這個程序那樣，使用顯式的字符編碼構造ir=new InputStreamReader(System.in, “8859_1″);
注：如果你通過網絡連接讀取字符，就應該使用這種形式。
否則，你的程序會總是試圖將所讀取的字符當作本地表示來進行轉換，而這並不總是正確的。ISO 8859-1是映射到ASCII的Latin-1編碼模式。
6、 對象串行化
java.io.Serializable接口支持將一個Java技術對象存放到一個流中。
將一個對象存放到某種類型的永久存儲器上稱爲”保持”。
如果一個對象可以被存放到磁盤或磁帶上，或者可以發送到另外一臺機器並存放到存儲器或磁盤上，那麼這個對象就被稱爲可保持的。
java.io.Serializable接口沒有任何方法，它只作爲一個”標記”，用來表明實現了這個接口的類可以串行化。
類中沒有實現Serializable接口的對象不能被保持。
// 文件實現追加：
// 其中的FileWriter()中的第二個參數的含義是:是否在文件中追加內容
PrintWriter out = new PrintWriter(new FileWriter(logFileName, true), true);
Java讀寫文件最常用的類是FileInputStream/FileOutputStream和FileReader/FileWriter。
其中FileInputStream和FileOutputStream是基於字節流的，常用於讀寫二進制文件。
讀寫字符文件建議使用基於字符的FileReader和FileWriter，省去了字節與字符之間的轉換。
但這兩個類的構造函數默認使用系統的編碼方式，如果文件內容與系統編碼方式不一致，可能會出現亂碼。
在這種情況下，建議使用FileReader和FileWriter的父類：InputStreamReader/OutputStreamWriter，
它們也是基於字符的，但在構造函數中可以指定編碼類型：InputStreamReader(InputStream in, Charset cs) 和OutputStreamWriter(OutputStream out, Charset cs)。
// 讀寫文件的編碼：
InputStreamReader r = new InputStreamReader(new FileInputStream(fileName), “utf-8″);
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(fileName),”utf-8″);
/**
三種IO性能比較:
在讀寫一個10k文件的時候，三種方式的耗時如下:
InputStreamReader And OutputStreamWriter : 63ms (可以設置文件的編碼，如果不用buffer)
BufferedReader And BufferedWriter : 31ms
BufferedInputStream And BufferedOutputStream : 16ms
*/
/**
* Description: Test the java IO’s efficiency
* Author: AllanCao
* Date: 2007-02-18
*/
import java.io.*;
/**
* using the InputStreamReader And OutputStreamWriter
*/
class EncoderRW {
public static String read(String fileName) throws IOException {
StringBuffer sb = new StringBuffer();
/*此處讀文件時用了buffer，如果不用，性能損失一倍*/
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(fileName), “utf-8″));
String s;
while((s = in.readLine()) != null) {
sb.append(s);
sb.append(”\n”);
}
in.close();
return sb.toString();
}
public void write(String fileName, String text) throws IOException {
OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(fileName),”utf-8″);
out.write(text);
out.flush();
out.close();
}
}
/**
* using the BufferedReader And BufferedWriter
*/
class WriterReader {
public String read(String fileName) throws IOException {
StringBuffer sb = new StringBuffer();
BufferedReader in = new BufferedReader(new FileReader(fileName));
String s;
while((s = in.readLine()) != null) {
sb.append(s);
sb.append(”\n”);
}
in.close();
return sb.toString();
}
public void write(String fileName, String text) throws IOException {
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
out.print(text);
out.close();
}
}
/**
* using the BufferedInputStream And BufferedOutputStream
*/
class BufferedStream{
public byte[] read(String fileName) throws IOException {
BufferedInputStream remoteBIS = new BufferedInputStream(new FileInputStream(fileName));
ByteArrayOutputStream baos = new ByteArrayOutputStream(10240);
byte[] buf = new byte[1024];
int bytesRead = 0;
while(bytesRead >= 0)
{
baos.write(buf, 0, bytesRead);
bytesRead = remoteBIS.read(buf);
}
byte[] content = baos.toByteArray();
return content;
}
public void write(String fileName, byte[] content) throws IOException {
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(fileName));
out.write(content);
out.flush();
out.close();
}
}
public class TestIO
{
public static void main(String[] args)throws IOException {
long currentTime = System.currentTimeMillis() ;
EncoderRW rw = new EncoderRW();
rw.write(”index.dat”,rw.read(”FileUtil.java”));
System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);
currentTime = System.currentTimeMillis() ;
WriterReader wr = new WriterReader();
wr.write(”index.dat”,wr.read(”FileUtil.java”));
System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);
currentTime = System.currentTimeMillis() ;
BufferedStream bf = new BufferedStream();
bf.write(”index.dat”,bf.read(”FileUtil.java”));
System.out.println(”cost time:” + Long.toString(System.currentTimeMillis()-currentTime) + ” ms”);
}
}