Java中的IO流知識總結

總結一：

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”);
 }
}