Android開發入門：I/O流使用介紹（下）

　　在上篇中，已經寫下了IO流概念以及對File類操作，. 此文是它的姊妹篇！本文以Demo為主，不會涉及太多概念！！！

• 輸入流： InputStream/Reader 擁有一系列read方法
  • InputStream 是字節輸入流的超類
  • Reader是字符輸入流的超類
• 輸出流： OutputStream/Writer 擁有一系列write方法
  • OutputStream 字節輸出類的超類
  • Writer 字符輸出流的超類

輸出流代碼：

static void demo0() throws Exception {  
         try (OutputStream outputStream = new FileOutputStream("demo1.txt")) {  
             outputStream.write("First 'demo' for how to use 'OutputStream' !" 
                     .getBytes());  
         }  
         System.out.println("Over");  
     } 

看到這段代碼，是不是感覺有點奇怪？別緊張.

1. 上段代碼是Java 7中異常新特性：try-with-resources: 它可以自行進行資源管理，例如上例就不需要手動close；需要注意的是：try(/* 此處可以是代碼塊 */)，這種語法節省的好多代碼。
2. OutputStream是個抽象類，它必須通過子類來進行實例化。
3. OutputStream主要分為二種功能
   1. 字入數據的write系列方法
      1. 參數為byte: 單一字節
      2. 參數為byte數組
      3. 參數為byte數組和數組中的起始位置與長度
   2. 流的控制
      1. 關閉：close
      2. 刷新保存：flush: 其實不必手動flush。第一：當內部緩沖期滿過，它會自動自動執行flush；第二：當invoke close方法時，會自動執行flush。

輸入流代碼：

static void demo1() throws IOException{  
         InputStream inputStream =null;  
         try {  
             inputStream = new FileInputStream("demo0.txt");  
             byte[] bb = new byte[1024];  //緩沖區  
             int temp;  
             while((temp=inputStream.read(bb))!=-1){  
                 System.out.println(new String(bb, 0, temp));  
             }  
         } catch (FileNotFoundException e) {  
             // TODO Auto-generated catch block  
             e.printStackTrace();  
         }finally{  
             if(inputStream!=null){  
                 inputStream.close();  
             }  
         }  
     } 

 InputStream：

1. 上段采用Java 6的語法，是不是明顯感覺到代碼量增多：從7行增加到18行。
2. 與OutputStream一樣是個抽象類。因為它們都是比較早設計的類，因此並沒有采用流行的面向接口編程思想。
3. 與OutputStream一樣也主要有二個功能：read系列方法，但是它的流的控制沒有flush而是添加了skip，mark這二個方法，平時用得少，感興趣的同學可以自行去查API。

Reader,Writer與InputStream,OutputStream基本功能相，這裡就不在解釋。深入理解了InputStream與OutputStream之後，學其它就很快；對於不同的處理流，查API就行！！

附上IO流體系結構表：

IO流體系結構 分類 字節輸入流 字節輸出流 字符輸入流 字符輸出流 抽象基類 InputStream OutputSteam Reader Writer 文件 FileInputStream FileOutputSteam FileReader FileWriter 數組 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter 緩沖 BufferedInputStream　 BufferedOutputStream BufferdReader

BufferWriter　　

對象 ObjectInputStream ObjectOutputStream     轉換     InputStreamReader OutputStreamWriter 打印   PrintStream   PrintWriter 字符串     StringReader StringWriter 管道 PipedInputStream PipedOutputStream PipedReader PipedWriter

 

這多類，該如何記憶，理解呢？ 我是這麼理解的。

首先把它們大致劃分為：節點流與處理流。節點流就是直接與物理節點，進行交互；而處理流通常直接處理的對象是節點流，是再上一層的包裝。

比如：如果想對read操作進行同步緩沖，可以使用BufferedInputStream:

static void demo2() throws Exception{  
         InputStream inputStream =null;  
         BufferedInputStream bufferedInputStream =null;  
         try {  
             inputStream = new FileInputStream("demo0.txt");  
             bufferedInputStream = new BufferedInputStream(inputStream);  
             byte[] bb = new byte[1024];  
             int temp=-1;  
             while((temp=bufferedInputStream.read(bb))!=-1){  
                 System.out.println(new String(bb,0,temp));  
             }  
         } catch (FileNotFoundException e) {  
             // TODO Auto-generated catch block  
             e.printStackTrace();  
         }finally{  
             if(inputStream!=null){  
                 inputStream.close();  
             }  
         }  
     } 

RandomAccessFile: 任意訪問內容類：既可以讀取文件內容，也可以向文件輸出數據，可以自由訪問文件的任意位置，它可以自由定位文件記錄指針。

二個重要方法：

1. long getFilePointer():　獲取文件記錄的當前指針位置
2. void seek(long position): 將文件的記錄指針特定position的位置。

使用RandomAccessFile 必須要設置模式：

1. r: 只讀
2. rw: 讀寫，如果不存在，則自動創建。
3. rws: 讀寫，讀文件內容與元數據改動都會同步更新到Target Device上；
4. rwd：與rws類似，差別在於，當元數據改動後，不會同步更新到Target Device

static void demo3() throws Exception{  
         RandomAccessFile file = new RandomAccessFile("demo0.txt", "rw");  
         System.out.println("Before invoke write:"+file.getFilePointer());  
         file.seek(file.length());  
         file.write("\nUsing RandomAccessFile Class".getBytes());  
           
         System.out.println("After invoke write:"+file.getFilePointer());  
         file.seek(0);  
         byte[] bb = new byte[1024];  
         int temp=-1;  
         while ((temp=file.read(bb))>0) {  
             System.out.println(new String(bb,0,temp));      
         }  
           
         file.close();  
     } 

如果要在指定的位置進行插入內容，那必須得把指定位置的內容進行緩存，不然會被替代。

static void demo4(String fileName,long position,String content) throws Exception{  
         RandomAccessFile file = new RandomAccessFile(fileName, "rws");  
         File tempFile = File.createTempFile("temp", null);  
           
         long currentLength = file.length();  
         if(position>currentLength){  
             return;  
             //Maybe you can setup position=currentLenght; Also you can setup anything what you want !!!  
         }  
         FileOutputStream fileOutputStream = new FileOutputStream(tempFile); // write data to "temp" file   
         FileInputStream fileInputStream = new FileInputStream(tempFile); // read data   
         byte[] bb = new byte[512];  
         int tempNum=-1;  
           
         file.seek(position);  
           
         while((tempNum=file.read(bb))>0){  
             fileOutputStream.write(bb, 0, tempNum);  
         }  
           
         file.seek(position); // Go back to position  
         file.write(content.getBytes());  
           
         while((tempNum=fileInputStream.read(bb))>0){  
             file.write(bb, 0, tempNum);  
         }  
           
         tempFile.deleteOnExit();  
         if(fileInputStream!=null){  
             fileInputStream.close();  
         }  
         if(fileOutputStream!=null){  
             fileOutputStream.close();  
         }  
           
         file.close();  
     }