節點流 和 處理流

• 節點流 和 處理流
  • • 一、基本介紹
    • 二、節點流 和 處理流 的區別和聯繫
    • 三、處理流的功能主要體現在以下兩個方面：
    • 四、處理流 — BufferedReader和BufferedWriter

• 節點流和處理流一覽圖：

​ 【圖片來源】http://t.csdn.cn/d52a1

一、基本介紹

1. 節點流：節點流可以從一個特定的數據源讀寫數據，如FIleReader、FileWriter

   

   

2. 處理流：處理流（也叫包裝流）是“連接”在已存在的流（節點流或處理流）之上，為程式提供更為強大的讀寫功能，也更加靈活，如BufferedReader、BufferedWriter。使用了修飾器設計模式。就是面向對象的封裝思想，消除不同數據之間的差異性，僅對外暴露介面。

   

二、節點流 和 處理流 的區別和聯繫

1. 節點流是底層流/低級流，直接跟數據源相接。

2. 處理流（包裝流）包裝結點流，即可以消除不同節點的實現差異，也可以提供更方便的方法來完成輸入輸出。

3. 處理流（也叫包裝流）對節點流進行包裝，使用了修飾器設計模式，不會直接與數據源相連

   /**
    * @author
    * @version 1.0
    * 模擬修飾器設計模式
    */
   public class Test_ {
       public static void main(String[] args) {
           BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
           bufferedReader_.readFiles(10);
   
           //希望通過BufferedReader_ 多次讀取字元串
           BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
           bufferedReader_1.readStrings(5);
       }
   }
   abstract class Reader_ {
       public void readFile_(){}
       public void readString_(){}
   
       //在Reader_抽象類，使用read方法統一管理
   //    public abstract void read();
       //後面在調用時就，利於對象動態綁定機制，綁定到對應的實現子類即可。
   }
   
   // 模擬節點流
   class FileReader_ extends Reader_{
       public void readFile_(){
           System.out.println("對文件進行讀取……");
       }
   //    public void read(){
   //        System.out.println("對文件進行讀取……");
   //    }
   }
   
   //模擬節點流
   class StringReader_ extends Reader_{
       public void readString_(){
           System.out.println("讀取字元串……");
       }
   //    public void read(){
   //        System.out.println("讀取字元串……");
   //    }
   }
   
   
   //模擬處理流/包裝流
   class BufferedReader_ extends Reader_{
       //註意裝飾器模式中，裝飾類和被裝飾類（約定俗成，而非必須）繼承自同一個父類。
       private Reader_ reader_;//屬性是 Reader_
   
       //接收Reader_子類對象
       public BufferedReader_(Reader_ reader_) {
           this.reader_ = reader_;
       }
   
       public void readFile(){
           reader_.readFile_();
       }
   
       //讓方法更靈活，多次讀取文件，或者加緩衝char[]....
       public void readFiles(int num){
           for (int i = 0; i < num; i++) {
               reader_.readFile_();
           }
       }
   
       //擴展 readString，批量處理字元串數據
       public void readStrings(int num){
           for (int i = 0; i < num; i++) {
               reader_.readString_();
           }
       }
   }
   
   

三、處理流的功能主要體現在以下兩個方面：

1. 性能的提高：主要以增加緩衝的方式來提高輸入和輸出的效率。
2. 操作的便捷：處理流提供了一系列便捷的方法來一次輸入輸出大批量的數據就，使用更加靈活方便。

四、處理流 — BufferedReader和BufferedWriter

• BufferedReader 和 BufferedWriter屬於字元流，是按照字元來讀取數據的；
• 關閉處理流，只需關閉外層流即可，關閉外層流（包裝流）時會自動關閉包裝的節點流；
• BufferedReader 和 BufferedWriter 是安裝字元操作，不要去操作二進位文件，可能造成文件損壞；

1. BufferedReader

   

   

   • 構造方法摘要

     Constructor and Description
     BufferedReader(Reader in)創建使用預設大小的輸入緩衝區的緩衝字元輸入流。
     BufferedReader(Reader in, int sz)創建使用指定大小的輸入緩衝區的緩衝字元輸入流。

   • 方法摘要

     Modifier and Type	Method and Description
     void	close()關閉流並釋放與之相關聯的任何系統資源。
     Stream<String>	lines()返回一個 Stream ，其元素是從這個 BufferedReader讀取的行。
     void	mark(int readAheadLimit)標記流中的當前位置。
     boolean	markSupported()告訴這個流是否支持mark（）操作。
     int	read()讀一個字元
     int	read(char[] cbuf, int off, int len)將字元讀入數組的一部分。
     String	readLine()讀一行文字。
     boolean	ready()告訴這個流是否準備好被讀取。
     void	reset()將流重置為最近的標記。
     long	skip(long n)跳過字元

   • 代碼演示：

     import java.io.BufferedReader;
     import java.io.FileNotFoundException;
     import java.io.FileReader;
     import java.io.IOException;
     
     /**
      * @author
      * @version 1.0
      * 演示BufferedReader的使用
      */
     public class BufferedReader_ {
         public static void main(String[] args) throws IOException {
             String filePath = "e:\\a.java";
             //創建BufferedReader對象
             BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
             //讀取
             String line;//按行讀取，效率高
             //1. bufferedReader.readLine() 是按行讀取文件
             //2. 當返回null時，表示文件讀取完畢
             while((line = bufferedReader.readLine()) != null){
                 System.out.println(line);
             }
     
             //關閉流
             //這裡註意，只需關閉 BufferedReader(外層流)，因為底層會自動的去關閉節點流 FileReader
             /**
              * public void close() throws IOException {
              *         synchronized (lock) {
              *             if (in == null)
              *                 return;
              *             try {
              *                 in.close();
              *             } finally {
              *                 in = null;// in 就是我們傳入的 new FileReader(filePath)，關閉了
              *                 cb = null;
              *             }
              *         }
              *     }
              */
             bufferedReader.close();
         }
     }
     
     

   2. BufferedWriter

      

      

      • 構造方法摘要

        Constructor and Description
        BufferedWriter(Writer out)創建使用預設大小的輸出緩衝區的緩衝字元輸出流。
        BufferedWriter(Writer out, int sz)創建一個新的緩衝字元輸出流，使用給定大小的輸出緩衝區。

      • 方法摘要

        Modifier and Type	Method and Description
        void	close()關閉流，先刷新。
        void	flush()刷新流。
        void	newLine()寫一行行分隔符。
        void	write(char[] cbuf, int off, int len)寫入字元數組的一部分。
        void	write(int c)寫一個字元
        void	write(String s, int off, int len)寫一個字元串的一部分。

      • 代碼演示：

        import java.io.BufferedWriter;
        import java.io.FileWriter;
        import java.io.IOException;
        
        public class BufferedWriter_ {
            public static void main(String[] args) throws IOException {
                String filePath = "e:\\BufferedWriter_.java";
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath, true));
                bufferedWriter.write("hello, 你好");
                //插入一個和系統 相關的換行
                bufferedWriter.newLine();
        //        bufferedWriter.write("\r\n");
                bufferedWriter.write("hello, 你好");
                //關閉外層流即可，傳入的節點流會自動關閉
                bufferedWriter.close();
        
            }
        }