淺談Java的輸入輸出流

Java語言的輸入輸出功能是十分強大而靈活的，美中不足的是看上去輸入輸出的代碼並非很簡潔，由於你每每須要包裝許多不一樣的對象。在Java類庫中，IO部分的內容是很龐大的，由於它涉及的領域很普遍:標準輸入輸出，文件的操做，網絡上的數據流，字符串流，對象流，zip文件流....本文的目的是爲你們作一個簡要的介紹。

　　流是一個很形象的概念，當程序須要讀取數據的時候，就會開啓一個通向數據源的流，這個數據源能夠是文件，內存，或是網絡鏈接。相似的，當程序須要寫入數據的時候，就會開啓一個通向目的地的流。這時候你就能夠想象數據好像在這其中「流」動同樣，以下圖：

　　Java中的流分爲兩種，一種是字節流，另外一種是字符流，分別由四個抽象類來表示（每種流包括輸入和輸出兩種因此一共四個）:InputStream，OutputStream，Reader，Writer。Java中其餘多種多樣變化的流均是由它們派生出來的:

 

 

在這其中InputStream和OutputStream在早期的Java版本中就已經存在了，它們是基於字節流的，而基於字符流的Reader和Writer是後來加入做爲補充的。以上的層次圖是Java類庫中的一個基本的層次體系。

　　在這四個抽象類中，InputStream和Reader定義了徹底相同的接口：

int read（）
int read（char cbuf[]）
int read（char cbuf[], int offset, int length）

　　而OutputStream和Writer也是如此：

int write（int c）
int write（char cbuf[]）
int write（char cbuf[], int offset, int length）

　　這六個方法都是最基本的，read（）和write（）經過方法的重載來讀寫一個字節，或者一個字節數組。

　　更多靈活多變的功能是由它們的子類來擴充完成的。知道了Java輸入輸出的基本層次結構之後，本文在這裏想給你們一些之後能夠反覆應用例子，對於全部子類的細節及其功能並不詳細討論。

import java.io.*；

public class IOStreamDemo {

      public void samples（） throws IOException {

           //1. 這是從鍵盤讀入一行數據,返回的是一個字符串
           BufferedReader stdin =new BufferedReader（new InputStreamReader（System.in））；
           System.out.print（"Enter a line:"）；
           System.out.println（stdin.readLine（））；

           //2. 這是從文件中逐行讀入數據

           BufferedReader in = new BufferedReader（new FileReader（"IOStreamDemo.java"））；
           String s, s2 = new String（）；
           while（（s = in.readLine（））!= null）
                      s2 += s + "\n"；
           in.close（）；

           //3. 這是從一個字符串中逐個讀入字節
           StringReader in1 = new StringReader（s2）；
           int c；
           while（（c = in1.read（）） != -1）
                      System.out.print（（char）c）；

           //4. 這是將一個字符串寫入文件
           try {
                      BufferedReader in2 = new BufferedReader（new StringReader（s2））；
                      PrintWriter out1 = new PrintWriter（new BufferedWriter（new FileWriter（"IODemo.out"）））；
                      int lineCount = 1；
                      while（（s = in2.readLine（）） != null ）
                                 out1.println（lineCount++ + ": " + s）；
                      out1.close（）；
           } catch（EOFException e） {
                      System.err.println（"End of stream"）；
           }
      }
}

　　對於上面的例子，須要說明的有如下幾點：

　　1. BufferedReader是Reader的一個子類，它具備緩衝的做用，避免了頻繁的從物理設備中讀取信息。它有如下兩個構造函數：

BufferedReader（Reader in）
BufferedReader（Reader in, int sz）

　　這裏的sz是指定緩衝區的大小。

　　它的基本方法：

void close（） //關閉流

           void mark（int readAheadLimit） //標記當前位置

           boolean markSupported（） //是否支持標記

           int read（） //繼承自Reader的基本方法

           int read（char[] cbuf, int off, int len） //繼承自Reader的基本方法

           String readLine（） //讀取一行內容並以字符串形式返回

           boolean ready（） //判斷流是否已經作好讀入的準備

           void reset（） //重設到最近的一個標記

           long skip（long n） //跳過指定個數的字符讀取

　　2. InputStreamReader是InputStream和Reader之間的橋樑，因爲System.in是字節流，須要用它來包裝以後變爲字符流供給             BufferedReader使用。

　　3. PrintWriter out1 = new PrintWriter（new BufferedWriter（new FileWriter（"IODemo.out"）））；

　　這句話體現了Java輸入輸出系統的一個特色，爲了達到某個目的，須要包裝好幾層。首先，輸出目的地是文件IODemo.out，因此最內層包裝的是FileWriter，創建一個輸出文件流，接下來，咱們但願這個流是緩衝的，因此用BufferedWriter來包裝它以達到目的，最後，咱們須要格式化輸出結果，因而將PrintWriter包在最外層。

　　Java提供了這樣一個功能，將標準的輸入輸出流轉向，也就是說，咱們能夠將某個其餘的流設爲標準輸入或輸出流，看下面這個例子：

import java.io.*；

public class Redirecting {

       public static void main（String[] args） throws IOException {
              PrintStream console = System.out；
              BufferedInputStream in = new BufferedInputStream（ new FileInputStream（ "Redirecting.java"））；
              PrintStream out = new PrintStream（ new BufferedOutputStream（ new FileOutputStream（"test.out"）））；
              System.setIn（in）；
              System.setOut（out）；

              BufferedReader br = new BufferedReader（ new InputStreamReader（System.in））；
              String s；
              while（（s = br.readLine（）） != null）
                     System.out.println（s）；
              out.close（）；
              System.setOut（console）；
      }
}
 　　在這裏java.lang.System的靜態方法

static void setIn（InputStream in）
static void setOut（PrintStream out）

　　提供了從新定義標準輸入輸出流的方法，這樣作是很方便的，好比一個程序的結果有不少，有時候甚至要翻頁顯示，這樣不便於觀看結果，這是你就能夠將標準輸出流定義爲一個文件流，程序運行完以後打開相應的文件觀看結果，就直觀了許多。

　　Java流有着另外一個重要的用途，那就是利用對象流對對象進行序列化。下面將開始介紹這方面的問題。

　　在一個程序運行的時候，其中的變量數據是保存在內存中的，一旦程序結束這些數據將不會被保存，一種解決的辦法是將數據寫入文件，而Java中提供了一種機制，它能夠將程序中的對象寫入文件，以後再從文件中把對象讀出來從新創建。這就是所謂的對象序列化Java中引入它主要是爲了RMI（Remote Method Invocation）和Java Bean所用，不過在平時應用中，它也是頗有用的一種技術。
全部須要實現對象序列化的對象必須首先實現Serializable接口。下面看一個例子：

import java.io.*；
import java.util.*；

public class Logon implements Serializable {

       private Date date = new Date（）；
       private String username；
       private transient String password；

       Logon（String name, String pwd） {
              username = name；
              password = pwd；
       }

       public String toString（） {
              String pwd = （password == null） ? "（n/a）" : password；
              return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd；
       }

       public static void main（String[] args） throws IOException, ClassNotFoundException {
              Logon a = new Logon（"Morgan", "morgan83"）；
              System.out.println（ "logon a = " + a）；
              ObjectOutputStream o = new ObjectOutputStream（ new FileOutputStream（"Logon.out"））；
              o.writeObject（a）；
              o.close（）；

              int seconds = 5；
              long t = System.currentTimeMillis（） + seconds * 1000；
              while（System.currentTimeMillis（） < t） ；

              ObjectInputStream in = new ObjectInputStream（ new FileInputStream（"Logon.out"））；
              System.out.println（ "Recovering object at " + new Date（））；
              a = （Logon）in.readObject（）；
              System.out.println（"logon a = " + a）；
       }
}
　　類Logon是一個記錄登陸信息的類，包括用戶名和密碼。首先它實現了接口Serializable，這就標誌着它能夠被序列化。以後再main方法裏ObjectOutputStream o = new ObjectOutputStream（ new FileOutputStream（"Logon.out"））；新建一個對象輸出流包裝一個文件流，表示對象序列化的目的地是文件Logon.out。而後用方法writeObject開始寫入。想要還原的時候也很簡單ObjectInputStream in = new ObjectInputStream（ new FileInputStream（"Logon.out"））；新建一個對象輸入流以文件流Logon.out爲參數，以後調用readObject方法就能夠了。

　　須要說明一點，對象序列化有一個神奇之處就是，它創建了一張對象網，將當前要序列化的對象中所持有的引用指向的對象都包含起來一塊兒寫入到文件，更爲奇妙的是，若是你一次序列化了好幾個對象，它們中相同的內容將會被共享寫入。這的確是一個很是好的機制。它能夠用來實現深層拷貝。

　　關鍵字transient在這裏表示當前內容將不被序列化，好比例子中的密碼，須要保密，因此沒有被寫入文件。

　　對Java的輸入輸出功能，就淺淺的介紹到這裏，本文的目的只是開一個好頭，但願能讓你們對Java輸入輸出流有個基本的認識。