java中的io中的（input/output）stream無非就是包括基于字符的stream、基于字節的stream和把字節導向的stream轉換
字符為導向的stream的stream。（很難理解么？）
以字節為導向的stream------InputStream/OutputStream
InputStream 和 OutputStream是兩個abstact類，對于字節為導向的stream都擴展這兩個雞肋（基類^_^）;
--InputStream
ByteArrayInputStream -- 把內存中的一個緩沖區作為InputStream使用.
construct---ByteArrayInputStream(byte[])創建一個新字節數組輸入流，它從指定字節數組中讀取數據。
---ByteArrayInputStream(byte[], int, int) 創建一個新字節數組輸入流，它從指定字節數組中讀取數據。
---mark::該字節數組未被復制。
StringBufferInputStream -- 把一個String對象作為InputStream .
注釋：不推薦使用 StringBufferInputStream 方法。 此類不能將字符正確的轉換為字節。
同 JDK 1.1 版中的類似，從一個串創建一個流的最佳方法是采用 StringReader 類。
construct---StringBufferInputStream(String) 據指定串創建一個讀取數據的輸入流串。
FileInputStream -- 把一個文件作為InputStream，實現對文件的讀取操作
construct---FileInputStream(File) 創建一個輸入文件流，從指定的 File 對象讀取數據。
---FileInputStream(FileDescriptor) 創建一個輸入文件流，從指定的文件描述器讀取數據。
---FileInputStream(String) 創建一個輸入文件流，從指定名稱的文件讀取數據。
method ---- read() 從當前輸入流中讀取一字節數據。
read(byte[]) 將當前輸入流中 b.length 個字節數據讀到一個字節數組中。
read(byte[], int, int) 將輸入流中 len 個字節數據讀入一個字節數組中。
PipedInputStream：實現了pipe的概念，主要在線程中使用. 管道輸入流是指一個通訊管道的接收端。
一個線程通過管道輸出流發送數據，而另一個線程通過管道輸入流讀取數據，
這樣可實現兩個線程間的通訊。
PipedInputStream() 創建一個管道輸入流，它還未與一個管道輸出流連接。
PipedInputStream(PipedOutputStream) 創建一個管道輸入流, 它已連接到一個管道輸出流。
SequenceInputStream：把多個InputStream合并為一個InputStream .“序列輸入流”類允許應用程序把幾個輸入流連續地合并起來，
并且使它們像單個輸入流一樣出現。每個輸入流依次被讀取，直到到達該流的末尾。
然后“序列輸入流”類關閉這個流并自動地切換到下一個輸入流。
SequenceInputStream(Enumeration) 創建一個新的序列輸入流，并用指定的輸入流的枚舉值初始化它。
SequenceInputStream(InputStream, InputStream) 創建一個新的序列輸入流，初始化為首先 讀輸入流 s1, 然后讀輸入流 s2。
--OutputSteam
ByteArrayOutputStream：把信息存入內存中的一個緩沖區中.該類實現一個以字節數組形式寫入數據的輸出流。
當數據寫入緩沖區時，它自動擴大。用 toByteArray() 和 toString() 能檢索數據。
construct --- ByteArrayOutputStream() 創建一個新的字節數組輸出流。
--- ByteArrayOutputStream() 創建一個新的字節數組輸出流。
--- ByteArrayOutputStream(int) 創建一個新的字節數組輸出流，并帶有指定大小字節的緩沖區容量。
toString(String) 根據指定字符編碼將緩沖區內容轉換為字符串，并將字節轉換為字符。
write(byte[], int, int) 將指定字節數組中從偏移量 off 開始的 len 個字節寫入該字節數組輸出流。
write(int) 將指定字節寫入該字節數組輸出流。
writeTo(OutputStream) 用 out.write(buf, 0, count) 調用輸出流的寫方法將該字節數組輸出流的全部內容寫入指定的輸出流參數。
FileOutputStream:文件輸出流是向 File 或 FileDescriptor 輸出數據的一個輸出流。
FileOutputStream(File) 創建一個文件輸出流，向指定的 File 對象輸出數據。
FileOutputStream(FileDescriptor) 創建一個文件輸出流，向指定的文件描述器輸出數據。
FileOutputStream(String) 創建一個文件輸出流，向指定名稱的文件輸出數據。
FileOutputStream(String, boolean) 用指定系統的文件名，創建一個輸出文件。
PipedOutputStream:管道輸出流是指一個通訊管道的發送端。 一個線程通過管道輸出流發送數據，
而另一個線程通過管道輸入流讀取數據，這樣可實現兩個線程間的通訊。
PipedOutputStream() 創建一個管道輸出流，它還未與一個管道輸入流連接。
PipedOutputStream(PipedInputStream) 創建一個管道輸出流，它已連接到一個管道輸入流。
以字符為導向的stream Reader/Writer
以Unicode字符為導向的stream，表示以Unicode字符為單位從stream中讀取或往stream 中寫入信息。
Reader/Writer 為abstact類
以Unicode字符為導向的stream包括下面幾種類型：
－－ Reader
1) CharArrayReader：與ByteArrayInputStream對應
CharArrayReader(char[]) 用指定字符數組創建一個 CharArrayReader。
CharArrayReader(char[], int, int) 用指定字符數組創建一個 CharArrayReader。
2) StringReader：與StringBufferInputStream對應
StringReader(String) 創建一新的串讀取者。
3) FileReader：與FileInputStream對應
4) PipedReader：與PipedInputStream對應
－－ Writer
1) CharArrayWrite：與ByteArrayOutputStream對應
2) StringWrite：無與之對應的以字節為導向的stream
3) FileWrite：與FileOutputStream對應
4) PipedWrite：與PipedOutputStream對應
兩種不現導向的stream之間的轉換
InputStreamReader和OutputStreamReader：把一個以字節為導向的stream轉換成一個以字符為導向的stream。
一個 InputStreamReader 類是從字節流到字符流的橋梁：它讀入字節，并根據指定的編碼方式，將之轉換為字符流。
使用的編碼方式可能由名稱指定，或平臺可接受的缺省編碼方式。
InputStreamReader 的 read() 方法之一的每次調用，可能促使從基本字節輸入流中讀取一個或多個字節。
為了達到更高效率，考慮用 BufferedReader 封裝 InputStreamReader，
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
InputStreamReader(InputStream) 用缺省的字符編碼方式，創建一個 InputStreamReader。
InputStreamReader(InputStream, String) 用已命名的字符編碼方式，創建一個 InputStreamReader。
OutputStreamWriter 將多個字符寫入到一個輸出流，根據指定的字符編碼將多個字符轉換為字節。
每個 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是從字符流到字節流的橋梁。
FilterInputStream、RandomAccessFile 見例子。
ObjectInputStream 、 ObjectOutputStream見另外blog。
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
決定使用哪個類以及它的構造進程的一般準則如下（不考慮特殊需要）：
首先，考慮最原始的數據格式是什么： 原則四
第二，是輸入還是輸出：原則五
第三，是否需要轉換流：原則六第1點
第四，數據來源（去向）是什么：原則一
第五，是否要緩沖：原則三 （特別注明：一定要注意的是readLine()是否有定義，有什么比read, write更特殊的輸入或輸出方法）
第六，是否要格式化輸出：原則二
文章2：
首先是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: KevinChen
* 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”);
}
}