java IO入門筆記

1.java IO流的概念，分類，類圖

1.1. java IO 流的概念

java的io是實現(xiàn)輸入和輸出的基礎，可以方便的實現(xiàn)數(shù)據(jù)的輸入和輸出操作。在java中把不同的輸入/輸出源（鍵盤，文件，網(wǎng)絡連接等）抽象表述為“流”(stream)。通過流的形式允許java程序使用相同的方式來訪問不同的輸入/輸出源。stram是從起源（source）到接收的（sink）的有序數(shù)據(jù)。

注：java把所有的傳統(tǒng)的流類型都放到在java io包下，用于實現(xiàn)輸入和輸出功能。

1.2 Io流的分類：

按照不同的分類方式，可以把流分為不同的類型。常用的分類有三種：

1.2.1 按照流的流向分，可以分為輸入流和輸出流。

  • 輸入流： 只能從中讀取數(shù)據(jù)，而不能向其寫入數(shù)據(jù)。
  • 輸出流：只能向其寫入數(shù)據(jù)，而不能向其讀取數(shù)據(jù)。
    此處的輸入,輸出涉及一個方向的問題，對于如圖15.1所示的數(shù)據(jù)流向，數(shù)據(jù)從內存到硬盤，通常稱為輸出流——也就是說，這里的輸入，輸出都是從程序運行所在的內存的角度來劃分的。

注：如果從硬盤的角度來考慮，圖15.1所示的數(shù)據(jù)流應該是輸入流才對；但劃分輸入/輸出流時是從程序運行所在的內存的角度來考慮的，因此如圖15.1所在的流時輸出流。而不是輸入流。

對于如圖15.2所示的數(shù)據(jù)流向，數(shù)據(jù)從服務器通過網(wǎng)絡流向客戶端，在這種情況下,Server端的內存負責將數(shù)據(jù)輸出到網(wǎng)絡里，因此Server端的程序使用輸出流；Client端的內存負責從網(wǎng)絡中讀取數(shù)據(jù)，因此Client端的程序應該使用輸入流。

20160505173519730.png

注：java的輸入流主要是InputStream和Reader作為基類，而輸出流則是主要由outputStream和Writer作為基類。它們都是一些抽象基類，無法直接創(chuàng)建實例。

1.2.2 按照操作單元劃分，可以劃分為字節(jié)流和字符流。

字節(jié)流和字符流的用法幾乎完成全一樣，區(qū)別在于字節(jié)流和字符流所操作的數(shù)據(jù)單元不同，字節(jié)流操作的單元是數(shù)據(jù)單元是8位的字節(jié)，字符流操作的是數(shù)據(jù)單元為16位的字符。

字節(jié)流主要是由InputStream和outPutStream作為基類，而字符流則主要有Reader和Writer作為基類。

1.2.3 按照流的角色劃分為節(jié)點流和處理流。

可以從/向一個特定的IO設備（如磁盤，網(wǎng)絡）讀/寫數(shù)據(jù)的流，稱為節(jié)點流。節(jié)點流也被稱為低級流。圖15.3顯示了節(jié)點流的示意圖。
?
從圖15.3中可以看出，當使用節(jié)點流進行輸入和輸出時，程序直接連接到實際的數(shù)據(jù)源，和實際的輸入/輸出節(jié)點連接。

處理流則用于對一個已存在的流進行連接和封裝，通過封裝后的流來實現(xiàn)數(shù)據(jù)的讀/寫功能。處理流也被稱為高級流。圖15.4顯示了處理流的示意圖。


20160505135650158.png

從圖15.4可以看出，當使用處理流進行輸入/輸出時，程序并不會直接連接到實際的數(shù)據(jù)源，沒有和實際的輸入和輸出節(jié)點連接。使用處理流的一個明顯的好處是，只要使用相同的處理流，程序就可以采用完全相同的輸入/輸出代碼來訪問不同的數(shù)據(jù)源，隨著處理流所包裝的節(jié)點流的變化，程序實際所訪問的數(shù)據(jù)源也相應的發(fā)生變化。

1.3 流的原理淺析和常用的流的分類表：

1.3.1 流的原理淺析:

java Io流共涉及40多個類，這些類看上去很雜亂，但實際上很有規(guī)則，而且彼此之間存在非常緊密的聯(lián)系， Java Io流的40多個類都是從如下4個抽象類基類中派生出來的。

  • InputStream/Reader: 所有的輸入流的基類，前者是字節(jié)輸入流，后者是字符輸入流。

  • OutputStream/Writer: 所有輸出流的基類，前者是字節(jié)輸出流，后者是字符輸出流。
    ?
    對于InputStream和Reader而言，它們把輸入設備抽象成為一個”水管“，這個水管的每個“水滴”依次排列，如圖15.5所示：
    ? ?
    從圖15.5可以看出，字節(jié)流和字符流的處理方式其實很相似，只是它們處理的輸入/輸出單位不同而已。輸入流使用隱式的記錄指針來表示當前正準備從哪個“水滴”開始讀取，每當程序從InputStream或者Reader里面取出一個或者多個“水滴”后，記錄指針自定向后移動；除此之外，InputStream和Reader里面都提供了一些方法來控制記錄指針的移動。


    20160505163728207.png

對于OutputStream和Writer而言，它們同樣把輸出設備抽象成一個”水管“，只是這個水管里面沒有任何水滴，如圖15.6所示：

正如圖15.6所示，當執(zhí)行輸出時，程序相當于依次把“水滴”放入到輸出流的水管中，輸出流同樣采用隱示指針來標識當前水滴即將放入的位置，每當程序向OutputStream或者Writer里面輸出一個或者多個水滴后，記錄指針自動向后移動。
? ?
圖15.5和圖15.6顯示了java Io的基本概念模型，除此之外，Java的處理流模型則體現(xiàn)了Java輸入和輸出流設計的靈活性。處理流的功能主要體現(xiàn)在以下兩個方面。

  • 性能的提高：主要以增加緩沖的方式來提供輸入和輸出的效率。
  • 操作的便捷：處理流可能提供了一系列便捷的方法來一次輸入和輸出大批量的內容，而不是輸入/輸出一個或者多個“水滴”。

處理流可以“嫁接”在任何已存在的流的基礎之上，這就允許Java應用程序采用相同的代碼，透明的方式來訪問不同的輸入和輸出設備的數(shù)據(jù)流。圖15.7顯示了處理流的模型。

20160505170600458.png

1.3.2 java輸入/輸出流體系中常用的流的分類表

| 分類 | 字節(jié)輸入流 |字節(jié)輸出流|字符輸入流|字符輸出流|

分類 字節(jié)輸入流 字節(jié)輸出流 字符輸入流 字符輸出流
抽象基類 InputStream OutputStream Reader Writer
訪問文件 FileInputStream FileOutputStream FileReader FileWriter
訪問數(shù)組 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter
訪問管道 PipedInputStream PipedOutputStream PipedReader PipedWriter
訪問字符串 StringReader StringWriter
緩沖流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
轉換流 InputStreamReader OutputStreamWriter
對象流 ObjectInputStream ObjectOutputStream
抽象基類 FilterInputStream FilterOutputStream FilterReader FilterWriter
打印流 PrintStream PrintWriter
推回輸入流 PushbackInputStream PushbackReader
特殊流 DataInputStream DataOutputStream

注：表中粗體字所標出的類代表節(jié)點流，必須直接與指定的物理節(jié)點關聯(lián)：斜體字標出的類代表抽象基類，無法直接創(chuàng)建實例。

2.常用的io流的用法

下面是整理的常用的Io流的特性及使用方法，只有清楚每個Io流的特性和方法。才能在不同的需求面前正確的選擇對應的IO流進行開發(fā)。

2.1 Io體系的基類（InputStream/Reader，OutputStream/Writer）。

字節(jié)流和字符流的操作方式基本一致，只是操作的數(shù)據(jù)單元不同——字節(jié)流的操作單元是字節(jié)，字符流的操作單元是字符。所以字節(jié)流和字符流就整理在一起了。

InputStream和Reader是所有輸入流的抽象基類，本身并不能創(chuàng)建實例來執(zhí)行輸入，但它們將成為所有輸入流的模板，所以它們的方法是所有輸入流都可使用的方法。

在InputStream里面包含如下3個方法。

  • int read(); 從輸入流中讀取單個字節(jié)（相當于從圖15.5所示的水管中取出一滴水），返回所讀取的字節(jié)數(shù)據(jù)（字節(jié)數(shù)據(jù)可直接轉換為int類型）。
  • int read(byte[] b)從輸入流中最多讀取b.length個字節(jié)的數(shù)據(jù)，并將其存儲在字節(jié)數(shù)組b中，返回實際讀取的字節(jié)數(shù)。
  • int read(byte[] b,int off,int len); 從輸入流中最多讀取len個字節(jié)的數(shù)據(jù)，并將其存儲在數(shù)組b中，放入數(shù)組b中時，并不是從數(shù)組起點開始，而是從off位置開始，返回實際讀取的字節(jié)數(shù)。

在Reader中包含如下3個方法。

  • int read(); 從輸入流中讀取單個字符（相當于從圖15.5所示的水管中取出一滴水），返回所讀取的字符數(shù)據(jù)（字節(jié)數(shù)據(jù)可直接轉換為int類型）。
  • int read(char[] b)從輸入流中最多讀取b.length個字符的數(shù)據(jù)，并將其存儲在字節(jié)數(shù)組b中，返回實際讀取的字符數(shù)。
  • int read(char[] b,int off,int len); 從輸入流中最多讀取len個字符的數(shù)據(jù)，并將其存儲在數(shù)組b中，放入數(shù)組b中時，并不是從數(shù)組起點開始，而是從off位置開始，返回實際讀取的字符數(shù)。

對比InputStream和Reader所提供的方法，就不難發(fā)現(xiàn)這兩個基類的功能基本是一樣的。InputStream和Reader都是將輸入數(shù)據(jù)抽象成如圖15.5所示的水管，所以程序即可以通過read()方法每次讀取一個”水滴“，也可以通過read（char[] chuf）或者read（byte[] b）方法來讀取多個“水滴”。當使用數(shù)組作為read（）方法中的參數(shù), 我們可以理解為使用一個“竹筒”到如圖15.5所示的水管中取水，如圖15.8所示read(char[] cbuf)方法的參數(shù)可以理解成一個”竹筒“，程序每次調用輸入流read(char[] cbuf)或read（byte[] b）方法，就相當于用“竹筒”從輸入流中取出一筒“水滴”，程序得到“竹筒”里面的”水滴“后，轉換成相應的數(shù)據(jù)即可；程序多次重復這個“取水”過程，直到最后。程序如何判斷取水取到了最后呢？直到read（char[] chuf）或者read（byte[] b）方法返回-1，即表明到了輸入流的結束點。


20160503905278.png

InputStream和Reader提供的一些移動指針的方法：

  • void mark(int readAheadLimit); 在記錄指針當前位置記錄一個標記（mark）。
  • boolean markSupported(); 判斷此輸入流是否支持mark()操作，即是否支持記錄標記。
  • void reset(); 將此流的記錄指針重新定位到上一次記錄標記（mark）的位置。
  • long skip(long n); 記錄指針向前移動n個字節(jié)/字符。

OutputStream和Writer：
OutputStream和Writer的用法也非常相似，它們采用如圖15.6所示的模型來執(zhí)行輸入，兩個流都提供了如下三個方法：

  • void write(int c); 將指定的字節(jié)/字符輸出到輸出流中，其中c即可以代表字節(jié)，也可以代表字符。
  • void write(byte[]/char[] buf); 將字節(jié)數(shù)組/字符數(shù)組中的數(shù)據(jù)輸出到指定輸出流中。
  • void write(byte[]/char[] buf, int off,int len ); 將字節(jié)數(shù)組/字符數(shù)組中從off位置開始，長度為len的字節(jié)/字符輸出到輸出流中。

因為字符流直接以字符作為操作單位，所以Writer可以用字符串來代替字符數(shù)組，即以String對象作為參數(shù)。Writer里面還包含如下兩個方法。

  • void write(String str); 將str字符串里包含的字符輸出到指定輸出流中。
  • void write (String str, int off, int len); 將str字符串里面從off位置開始，長度為len的字符輸出到指定輸出流中。

2.2 Io體系的基類文件流的使用(FileInputStream/FileReader ，F(xiàn)ileOutputStream/FileWriter)

前面說過InputStream和Reader都是抽象類，本身不能創(chuàng)建實例，但它們分別有一個用于讀取文件的輸入流：FileInputStream和FileReader，它們都是節(jié)點流——會直接和指定文件關聯(lián)。下面程序示范使用FileInputStream和FileReader。

使用FileInputStream讀取文件：

public class MyClass {
  public  static void main(String[] args)throws IOException{
      FileInputStream fis=null;
      try {
          //創(chuàng)建字節(jié)輸入流
          fis=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
          //創(chuàng)建一個長度為1024的竹筒
          byte[] b=new byte[1024];
          //用于保存的實際字節(jié)數(shù)
          int hasRead=0;
          //使用循環(huán)來重復取水的過程
          while((hasRead=fis.read(b))>0){
              //取出竹筒中的水滴（字節(jié)），將字節(jié)數(shù)組轉換成字符串進行輸出
            System.out.print(new String(b,0,hasRead));
          }
      }catch (IOException e){
        e.printStackTrace();
      }finally {
          fis.close();
      }
  }
}

注：上面程序最后使用了fis.close()來關閉該文件的輸入流，與JDBC編程一樣，程序里面打開的文件IO資源不屬于內存的資源，垃圾回收機制無法回收該資源，所以應該顯示的關閉打開的IO資源。Java 7改寫了所有的IO資源類，它們都實現(xiàn)了AntoCloseable接口，因此都可以通過自動關閉資源的try語句來關閉這些Io流。

使用FileReader讀取文件：

public class FileReaderTest {
    public  static void main(String[] args)throws IOException{
        FileReader fis=null;
        try {
            //創(chuàng)建字節(jié)輸入流
            fis=new FileReader("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
            //創(chuàng)建一個長度為1024的竹筒
            char[] b=new char[1024];
            //用于保存的實際字節(jié)數(shù)
            int hasRead=0;
            //使用循環(huán)來重復取水的過程
            while((hasRead=fis.read(b))>0){
                //取出竹筒中的水滴（字節(jié)），將字節(jié)數(shù)組轉換成字符串進行輸出
                System.out.print(new String(b,0,hasRead));
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fis.close();
        }
    }
}

可以看出使用FileInputStream和FileReader進行文件的讀寫并沒有什么區(qū)別，只是操作單元不同而且。

FileOutputStream/FileWriter是Io中的文件輸出流，下面介紹這兩個類的用法。

FileOutputStream的用法：

public class FileOutputStreamTest {
    public  static void main(String[] args)throws IOException {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //創(chuàng)建字節(jié)輸入流
            fis=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
            //創(chuàng)建字節(jié)輸出流
            fos=new FileOutputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\newTest.txt");

            byte[] b=new byte[1024];
            int hasRead=0;

            //循環(huán)從輸入流中取出數(shù)據(jù)
            while((hasRead=fis.read(b))>0){
                //每讀取一次，即寫入文件輸入流，讀了多少，就寫多少。
                fos.write(b,0,hasRead);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            fis.close();
            fos.close();
        }
    }
}

運行程序可以看到輸出流指定的目錄下多了一個文件：newTest.txt, 該文件的內容和Test.txt文件的內容完全相同。FileWriter的使用方式和FileOutputStream基本類似，這里就帶過。

注： 使用java的io流執(zhí)行輸出時，不要忘記關閉輸出流，關閉輸出流除了可以保證流的物理資源被回收之外，可能還可以將輸出流緩沖區(qū)中的數(shù)據(jù)flush到物理節(jié)點中里（因為在執(zhí)行close（）方法之前，自動執(zhí)行輸出流的flush（）方法）。java很多輸出流默認都提供了緩存功能，其實我們沒有必要刻意去記憶哪些流有緩存功能，哪些流沒有，只有正常關閉所有的輸出流即可保證程序正常。

緩沖流的使用（BufferedInputStream/BufferedReader, BufferedOutputStream/BufferedWriter）：
下面介紹字節(jié)緩存流的用法（字符緩存流的用法和字節(jié)緩存流一致就不介紹了）：

public class BufferedStreamTest {
    public  static void main(String[] args)throws IOException {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
            //創(chuàng)建字節(jié)輸入流
            fis=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
            //創(chuàng)建字節(jié)輸出流
            fos=new FileOutputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\newTest.txt");
            //創(chuàng)建字節(jié)緩存輸入流
            bis=new BufferedInputStream(fis);
            //創(chuàng)建字節(jié)緩存輸出流
            bos=new BufferedOutputStream(fos);

            byte[] b=new byte[1024];
            int hasRead=0;
            //循環(huán)從緩存流中讀取數(shù)據(jù)
            while((hasRead=bis.read(b))>0){
                //向緩存流中寫入數(shù)據(jù)，讀取多少寫入多少
                bos.write(b,0,hasRead);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            bis.close();
            bos.close();
        }
    }
}

可以看到使用字節(jié)緩存流讀取和寫入數(shù)據(jù)的方式和文件流（FileInputStream,FileOutputStream）并沒有什么不同，只是把處理流套接到文件流上進行讀寫。緩存流的原理下節(jié)介紹。

上面代碼中我們使用了緩存流和文件流，但是我們只關閉了緩存流。這個需要注意一下，當我們使用處理流套接到節(jié)點流上的使用的時候，只需要關閉最上層的處理就可以了。java會自動幫我們關閉下層的節(jié)點流。

2.3 轉換流的使用（InputStreamReader/OutputStreamWriter）:

下面以獲取鍵盤輸入為例來介紹轉換流的用法。java使用System.in代表輸入。即鍵盤輸入，但這個標準輸入流是InputStream類的實例，使用不太方便，而且鍵盤輸入內容都是文本內容，所以可以使用InputStreamReader將其包裝成BufferedReader,利用BufferedReader的readLine()方法可以一次讀取一行內容，如下代碼所示:

public class InputStreamReaderTest {
    public  static void main(String[] args)throws IOException {
        try {
            // 將System.in對象轉化為Reader對象
            InputStreamReader reader=new InputStreamReader(System.in);
            //將普通的Reader包裝成BufferedReader
            BufferedReader bufferedReader=new BufferedReader(reader);
           String buffer=null;
           while ((buffer=bufferedReader.readLine())!=null){
            // 如果讀取到的字符串為“exit”,則程序退出
               if(buffer.equals("exit")){
                   System.exit(1);
               }
               //打印讀取的內容
               System.out.print("輸入內容："+buffer);
           }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
        }
    }
}

上面程序將System.in包裝成BufferedReader,BufferedReader流具有緩存功能，它可以一次讀取一行文本——以換行符為標志，如果它沒有讀到換行符，則程序堵塞。等到讀到換行符為止。運行上面程序可以發(fā)現(xiàn)這個特征，當我們在控制臺執(zhí)行輸入時，只有按下回車鍵，程序才會打印出剛剛輸入的內容。

2.4 對象流的使用（ObjectInputStream/ObjectOutputStream）的使用：

寫入對象：

public static void writeObject(){
        OutputStream outputStream=null;
        BufferedOutputStream buf=null;
        ObjectOutputStream obj=null;
        try {
            //序列化文件輸出流
            outputStream=new FileOutputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\myfile.tmp");
            //構建緩沖流
            buf=new BufferedOutputStream(outputStream);
            //構建字符輸出的對象流
            obj=new ObjectOutputStream(buf);
            //序列化數(shù)據(jù)寫入
            obj.writeObject(new Person("A", 21));//Person對象
            //關閉流
            obj.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

讀取對象：

/**
     * 讀取對象
     */
    public static void readObject() throws IOException {
        try {
            InputStream inputStream=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\myfile.tmp");
            //構建緩沖流
            BufferedInputStream buf=new BufferedInputStream(inputStream);
            //構建字符輸入的對象流
            ObjectInputStream obj=new ObjectInputStream(buf);
            Person tempPerson=(Person)obj.readObject();
            System.out.println("Person對象為："+tempPerson);
            //關閉流
            obj.close();
            buf.close();
            inputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

使用對象流的一些注意事項

  1. 讀取順序和寫入順序一定要一致，不然會讀取出錯。
  2. 在對象屬性前面加transient關鍵字，則該對象的屬性不會被序列化。

4.何為NIO,和傳統(tǒng)Io有何區(qū)別？

我們使用InputStream從輸入流中讀取數(shù)據(jù)時，如果沒有讀取到有效的數(shù)據(jù)，程序將在此處阻塞該線程的執(zhí)行。其實傳統(tǒng)的輸入里和輸出流都是阻塞式的進行輸入和輸出。 不僅如此，傳統(tǒng)的輸入流、輸出流都是通過字節(jié)的移動來處理的（即使我們不直接處理字節(jié)流，但底層實現(xiàn)還是依賴于字節(jié)處理），也就是說，面向流的輸入和輸出一次只能處理一個字節(jié)，因此面向流的輸入和輸出系統(tǒng)效率通常不高。

從JDk1.4開始，java提供了一系列改進的輸入和輸出處理的新功能，這些功能被統(tǒng)稱為新IO(NIO)。新增了許多用于處理輸入和輸出的類，這些類都被放在java.nio包及其子包下，并且對原io的很多類都以NIO為基礎進行了改寫。新增了滿足NIO的功能。
? ?
NIO采用了內存映射對象的方式來處理輸入和輸出，NIO將文件或者文件的一塊區(qū)域映射到內存中，這樣就可以像訪問內存一樣來訪問文件了。通過這種方式來進行輸入/輸出比傳統(tǒng)的輸入和輸出要快的多。

JDk1.4使用NIO改寫了傳統(tǒng)Io后，傳統(tǒng)Io的讀寫速度和NIO差不了太多。

5.在開發(fā)中正確使用Io流

了解了java io的整體類結構和每個類的一下特性后，我們可以在開發(fā)的過程中根據(jù)需要靈活的使用不同的Io流進行開發(fā)。下面是我整理2點原則:

  • 如果是操作二進制文件那我們就使用字節(jié)流，如果操作的是文本文件那我們就使用字符流。
  • 盡可能的多使用處理流，這會使我們的代碼更加靈活，復用性更好。
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 概述 java.io 包幾乎包含了所有操作輸入、輸出需要的類。所有這些流類代表了輸入源和輸出目標。java.io ...
    Steven1997閱讀 9,232評論 1贊 25
  • tags:io categories:總結 date: 2017-03-28 22:49:50 不僅僅在JAVA領...
    行徑行閱讀 2,199評論 0贊 3
  • JavaScript 一個設定的時間間隔之后來執(zhí)行代碼稱之為計時事件 在 JavaScritp 中使用計時事件是很...
    S大偉閱讀 168評論 0贊 0
  • 東臨碣石，以觀滄海。 水何澹澹，山島竦峙。 樹木叢生，百草豐茂。 秋風蕭瑟，洪波涌起 不，不，不，應該是...
    青梅3煮酒閱讀 439評論 5贊 2
  • 一件事情發(fā)展 一波三折 好壞參半 所以看你怎么看咯
    良辰美LiangChen閱讀 183評論 0贊 0