編程語言的I/O類庫中常常使用流這個抽象的概念，它代表任何有能力產生數據的數據源對象或時有能力接收數據的接收端對象。“流”概念源於UNIX中的管道（pipe）的概念。在UNIX中，管道是一條不間斷的字節流，用來實現程序或進程間的通信，或讀寫外圍設備、外部文件等，它屏蔽了實際的I/O設備中處理數據的細節。 一個流，必有源端和目的端，它們可以是計算機內存的某些區域，也可以是磁盤文件，甚至可以是Internet上的某個URL。 流的方向是重要的，根據流的方向，流可以分爲兩類：輸入流和輸出流。其實輸入/輸出是想對於內存來說的。 實際上，流的源端和目的端可簡單地看成是字節的生產者和消費者，對於輸入流，可不必關心它的源端是什麼，只要簡單地從流中讀數據，而對輸出流，也可不知道它的目的端，只是簡單地往流中寫數據。
1: a.流：一組有序的數據序列。
2: b.字節流：數據流中最小的數據單元是字節。
3: c.字符流：數據流中最小的數據單元是字符。
一。 java.io包中的類對應兩類流，
一類流直接從指定的位置（如磁盤文件或內存區域）讀或寫，這類流稱爲結點流，其他的流則稱爲過濾流（包裝流）
過濾流：一些流可以從文件以及其他地方接收字節，另一些流可以將字節組合成更有用的數據類型。將一個已經存在的流傳遞給另一個流的構造方法，將這兩種流結合起來，結合後的流被稱爲過濾流。過濾器輸入流往往是以其它輸入流作爲它的輸入源，經過過濾或處理後再以新的輸入流的形式提供給用戶，過濾器輸出流也類似。 我們很少用單一的類來創建流對象，而是通過疊合多個對象來提供所期望的功能（即裝飾器設計模式）。
java的常用輸入、輸出流其實都是繼承自4個抽象類，分別是
基於單字節的InputStream,OutputStream類（面向字節形式的Ｉ/Ｏ）
基於雙字節的Unicode代碼單元的 Reader， Writer類（面向字符形式的Ｉ/Ｏ）
一旦打開輸入流後，程序就可從輸入流串行地讀數據。從輸入流讀/寫數據的過程一般如下：打開一個流通道-->讀取/寫信息-->關閉流通道。
在java平臺中，有以下兩種方式能獲得本地平臺的字符編碼類型：
（a）System.getProperty("file.encoding");
（b) Charset cs=Charset.defaultCharset();
所有的輸入流、輸出流都可以分爲字節（輸入、輸出）流，字符（輸入、輸出）流，處理字節的主要是（OutputStream/InputStream） 系列，處理字符的，主要是（Reader/Write）系列
二。以字節（Byte）爲導向的輸入流（InputStream系列），這幾個類都可以與FileInputStream對象相連以提供有用接口：
1) ByteArrayInputStream：把內存中的一個緩衝區作爲InputStream使用
2) StringBufferInputStream(在java1.1中已經棄用了
)：把一個String對象作爲InputStream，底層實現使用StringBuffer
3) FileInputStream：把一個文件作爲InputStream，實現對文件的讀取操作(文件名、文件、FileDescriptor對象)
4) PipedInputStream：實現了pipe的概念，主要在線程中使用（作爲多進程中的數據源）
5) SequenceInputStream：把多個InputStream合併爲一個InputStream
以字節（Byte）爲導向的輸出流（OutputStream系列），可以與ＦilterOutputStream對象相連以提供有用接口：
1) ByteArrayOutputStream：在內存中創建緩衝區，把信息存入內存中的一個緩衝區中，緩衝區初始化尺寸（可選）
2) FileOutputStream：把信息存入文件中（文件名、文件、FileDescriptor）
3) PipedOutputStream：實現了pipe的概念，主要在線程中使用(指定用於多線程的數據的目的地)
三。與之對應的（Reader/Writer）系列：
1: Reader: 與InputStream相對應，適配器InputStreamReader
2: Writer: 與OutputStream相對應，適配器爲OutputStreamWriter
3: FileReader： 與FileOutputStream相對應
4: FileWriter: 與FileOurputStream相對應
5: StringReader: 無相對應的類
6: StringWriter: 與ByteArrayInputStream相對應
7: CharArrayReader: 與ByteArrayOutputStream相對應
8: CharArrayWriter: 與ByteArrayOutputStream相對應
9: PipedReader: 與PipedInputStream相對應
10: PipedWriter: 與PipedOutputStream相對應
四。兩種不限導向的stream之間的轉換(使用適配器類)
InputStreamReader和OutputStreamReader：把一個以字節爲導向的stream轉換成一個以字符爲導向的stream。
InputStreamReader 是字節流通向字符流的橋樑：它使用指定的 charset 讀取字節並將其解碼爲字符。它使用的字符集可以由名稱指定或顯式給定，或者可以接受平臺默認的字符集
OutputStreamWriter 是字符流通向字節流的橋樑：可使用指定的 charset 將要寫入流中的字符編碼成字節。它使用的字符集可以由名稱指定或顯式給定，否則將接受平臺默認的字符集
五。通過FilterInputStream從InputStream讀取數據：
1) DataInputStream：從stream中讀取基本類型（int、char，long等）數據。
2) BufferedInputStream：使用緩衝區 ，使用它可以防止每次讀取都得進行實際的讀操作
3) LineNumberInputStream：會記錄input stream內的行數，然後可調用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用於編譯器開發
通過FilterOutputStream向OutputStream寫入：
1) DataIOutputStream：可以按照移植方式往stream中輸出基本類型（int、char，ｌｏｎｇ等）數據。
2) BufferedOutputStream：使用緩衝區 ，使用它可避免每次發送數據都進行實際的寫操作
3) PrintStream：產生格式化輸出 ，其中DataOutputStream處理數據的存儲，PrintStream處理顯示
六。更改流的行爲：
儘管BufferedOutputStream是FilterOutputStream的子類，但是BufferedWriter並不是FilterWriter的子類，（FilterWriter是抽象類，沒有任何子類）
1) 沒有與DataInputStream對應的類。除非在要使用readLine()時改用BufferedReader，否則使用DataInputStream
2) BufferedReader：與BufferedInputStream對應
3) LineNumberReader：與LineNumberInputStream對應
4) PushBackReader：與PushbackInputStream對應
5) BufferedWrite：與BufferedOutStream對應
6) PrintWrite：與 PrintStream對應
七。自我獨立的類:RandomAccessFile:
這個類適用於有大小已知的記錄組成的文件，RandomAccessFile除了實現了DataInput和DataOutput接口（DataInputStream和DataOutputStream也實現了這兩個接口）之外，這個類是個完全獨立的類，它擁有和別的I/O類型本質不同的行爲，可以在一個文件內向前和向後移動，直接從Object派生而來。
1) 可通過RandomAccessFile對象完成對文件的讀寫操作
2) 在產生一個對象時，可指明要打開的文件的性質：r，只讀；w，只寫；rw可讀寫
3) 可以直接跳到文件中指定的位置RandomAccessFile的大部分功能（不是全部）有nio存儲映射文件所取代
八．I/O流的典型使用方式：
1。緩衝輸入文件
1: import java.io.BufferedReader;
2: import java.io.FileReader;
3: import java.io.IOException;
4:
5: public class BufferedInputFile {
6: public static String read(String filename) throws IOException{
7: BufferedReader in=new BufferedReader(new FileReader(filename));
8: String s;
9: StringBuilder sb=new StringBuilder();
10: while((s=in.readLine())!=null){
11: sb.append(s+"\n");
12: }
13: in.close();
14: return sb.toString();
15: }
16: public static void main(String[] args) throws IOException {
17: System.out.println(read("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\
18:
19: \BufferedInputFile.java"));
20: }
21: }
2。從內存輸入
1: import java.io.IOException;
2: import java.io.StringReader;
3:
4: public class MemoryTest {
5: public static void main(String[] args) throws IOException {
6: StringReader in=new StringReader(BufferedInputFile.read("C:\\Users\\wubin\
7:
8: \workspace\\Imp\\src\\no9\\BufferedInputFile.java"));
9: int c;
10: while((c=in.read())!=-1)
11: System.out.print((char)c);
12: }
13: }
3。格式化的內存輸入
1: import java.io.ByteArrayInputStream;
2: import java.io.DataInputStream;
3: import java.io.IOException;
4:
5: public class FormattedMemoryInput {
6: public static void main(String[] args) throws IOException{
7: try{
8: DataInputStream in=new DataInputStream(new ByteArrayInputStream
9:
10: (BufferedInputFile.read("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\
11:
12: \BufferedInputFile.java").getBytes()));
13: while(true)
14: System.out.print((char)in.readByte());
15: }catch(Exception e){
16:
17: }
18: }
19: }
1: import java.io.BufferedInputStream;
2: import java.io.DataInputStream;
3: import java.io.FileInputStream;
4: import java.io.FileNotFoundException;
5: import java.io.IOException;
6:
7: public class TestEOF {
8: public static void main(String[] args) throws IOException {
9: DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream
10:
11: ("C:\\Users\\wubin\\workspace\\Imp\\src\\no9\\BufferedInputFile.java")));
12: while(in.available()!=0)
13: System.out.print((char)in.readByte());
14: }
15: }
16:
4。基本文件輸出
1: import java.io.BufferedReader;
2: import java.io.BufferedWriter;
3: import java.io.FileWriter;
4: import java.io.IOException;
5: import java.io.PrintWriter;
6: import java.io.StringReader;
7:
8: public class BasicFileOutput {
9: static String file="E:\\2.txt";
10: public static void main(String[] args) throws IOException {
11: BufferedReader in=new BufferedReader(new StringReader(BufferedInputFile.read("E:\
12:
13: \1.txt")));
14: PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(file)));
15: int cout=1;
16: String s;
17: while((s=in.readLine())!=null)
18: out.println(cout++ +" "+s);
19: out.close();
20: System.out.println(BufferedInputFile.read(file));
21: }
22: }
5。存儲和恢復數據
1: import java.io.BufferedInputStream;
2: import java.io.BufferedOutputStream;
3: import java.io.DataInputStream;
4: import java.io.DataOutputStream;
5: import java.io.FileInputStream;
6: import java.io.FileOutputStream;
7: import java.io.IOException;
8:
9: public class StoringAndRecoveringData {
10: public static void main(String[] args) throws IOException{
11: DataOutputStream out=new DataOutputStream(
12: new BufferedOutputStream(new FileOutputStream("E:\\1.txt")));
13: out.writeUTF("hello");
14: out.writeDouble(1.23);
15: out.writeInt(3);
16: out.close();
17: DataInputStream in=new DataInputStream(
18: new BufferedInputStream(new FileInputStream("E:\\1.txt")));
19: System.out.println(in.readUTF());
20: System.out.println(in.readDouble());
21: System.out.println(in.readInt());
22: }
23: }
6。讀寫隨機訪問文件
1: import java.io.IOException;
2: import java.io.RandomAccessFile;
3:
4: public class UsingRandomAccessFile {
5: static String file="E:\\1.txt";
6: static void display() throws IOException{
7: RandomAccessFile rf=new RandomAccessFile(file,"r");
8: for(int i=0;i<7;i++)
9: System.out.println("Value "+i+": "+rf.readDouble());
10: System.out.println(rf.readUTF());
11: rf.close();
12: }
13: public static void main(String[] args) throws IOException{
14: RandomAccessFile rf=new RandomAccessFile(file,"rw");
15: for(int i=0;i<7;i++)
16: rf.writeDouble(i*1.414);
17: rf.writeUTF("The end of the file");
18: rf.close();
19: display();
20: rf=new RandomAccessFile(file,"rw");
21: rf.seek(5*8);
22: rf.writeDouble(42.0001);
23: rf.close();
24: display();
25: }
26: }
PipedInputStream，PipedOutputStream,PipedReader和PipedWriter的價值體現在多線程上（管道流用於任務之間的通信）