主要內容

• File類
• 遞迴
• IO流
• 位元組流
• 字元流
• 異常處理
• Properties
• 緩衝流
• 轉換流
• 序列化流
• 列印流

學習目標

• [ ] 能夠說出File物件的建立方式
• [ ] 能夠說出File類獲取名稱的方法名稱
• [ ] 能夠說出File類獲取絕對路徑的方法名稱
• [ ] 能夠說出File類獲取檔案大小的方法名稱
• [ ] 能夠說出File類判斷是否是檔案的方法名稱
• [ ] 能夠說出File類判斷是否是資料夾的方法名稱
• [ ] 能夠辨別相對路徑和絕對路徑
• [ ] 能夠遍歷資料夾
• [ ] 能夠解釋遞迴的含義
• [ ] 能夠說出使用遞迴會記憶體溢位隱患的原因
• [ ] 能夠說出IO流的分類和功能
• [ ] 能夠使用位元組輸出流寫出資料到檔案
• [ ] 能夠使用位元組輸入流讀取資料到程式
• [ ] 能夠理解讀取資料read(byte[])方法的原理
• [ ] 能夠使用位元組流完成檔案的複製
• [ ] 能夠使用FileWirter寫資料到檔案
• [ ] 能夠說出FileWriter中關閉和重新整理方法的區別
• [ ] 能夠使用FileWriter寫資料的5個方法
• [ ] 能夠使用FileWriter寫資料實現換行和追加寫
• [ ] 能夠使用FileReader讀資料
• [ ] 能夠使用FileReader讀資料一次一個字元陣列
• [ ] 能夠使用Properties的load方法載入檔案中配置資訊
• [ ] 能夠使用位元組緩衝流讀取資料到程式
• [ ] 能夠使用位元組緩衝流寫出資料到檔案
• [ ] 能夠明確字元緩衝流的作用和基本用法
• [ ] 能夠使用緩衝流的特殊功能
• [ ] 能夠闡述編碼表的意義
• [ ] 能夠使用轉換流讀取指定編碼的文字檔案
• [ ] 能夠使用轉換流寫入指定編碼的文字檔案
• [ ] 能夠說出列印流的特點
• [ ] 能夠使用序列化流寫出物件到檔案
• [ ] 能夠使用反序列化流讀取檔案到程式中

第一章 File類

1.1 概述

java.io.File 類是檔案和目錄路徑名的抽象表示，主要用於檔案和目錄的建立、查詢和刪除等操作。

1.2 構造方法

• public File(String pathname) ：通過將給定的路徑名字串轉換為抽象路徑名來建立新的 File例項。
  
• public File(String parent, String child) ：從父路徑名字串和子路徑名字串建立新的 File例項。

• public File(File parent, String child) ：從父抽象路徑名和子路徑名字串建立新的 File例項。

• 構造舉例，程式碼如下：

// 檔案路徑名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname); 

// 檔案路徑名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2); 

// 通過父路徑和子路徑字串
 String parent = "d:\\aaa";
 String child = "bbb.txt";
 File file3 = new File(parent, child);

// 通過父級File物件和子路徑字串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

小貼士：

1. 一個File物件代表硬碟中實際存在的一個檔案或者目錄。
2. 無論該路徑下是否存在檔案或者目錄，都不影響File物件的建立。

1.3 常用方法

獲取功能的方法

• public String getAbsolutePath() ：返回此File的絕對路徑名字串。

• public String getPath() ：將此File轉換為路徑名字串。

• public String getName() ：返回由此File表示的檔案或目錄的名稱。

• public long length() ：返回由此File表示的檔案的長度。

  方法演示，程式碼如下：

  public class FileGet {
      public static void main(String[] args) {
          File f = new File("d:/aaa/bbb.java");     
          System.out.println("檔案絕對路徑:"+f.getAbsolutePath());
          System.out.println("檔案構造路徑:"+f.getPath());
          System.out.println("檔名稱:"+f.getName());
          System.out.println("檔案長度:"+f.length()+"位元組");
  
          File f2 = new File("d:/aaa");     
          System.out.println("目錄絕對路徑:"+f2.getAbsolutePath());
          System.out.println("目錄構造路徑:"+f2.getPath());
          System.out.println("目錄名稱:"+f2.getName());
          System.out.println("目錄長度:"+f2.length());
      }
  }
  輸出結果：
  檔案絕對路徑:d:\aaa\bbb.java
  檔案構造路徑:d:\aaa\bbb.java
  檔名稱:bbb.java
  檔案長度:636位元組
  
  目錄絕對路徑:d:\aaa
  目錄構造路徑:d:\aaa
  目錄名稱:aaa
  目錄長度:4096

API中說明：length()，表示檔案的長度。但是File物件表示目錄，則返回值未指定。

絕對路徑和相對路徑

• 絕對路徑：從碟符開始的路徑，這是一個完整的路徑。
• 相對路徑：相對於專案目錄的路徑，這是一個便捷的路徑，開發中經常使用。

public class FilePath {
    public static void main(String[] args) {
        // D盤下的bbb.java檔案
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
        
        // 專案下的bbb.java檔案
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
輸出結果：
D:\bbb.java
D:\idea_project_test4\bbb.java

判斷功能的方法

• public boolean exists() ：此File表示的檔案或目錄是否實際存在。
• public boolean isDirectory() ：此File表示的是否為目錄。
• public boolean isFile() ：此File表示的是否為檔案。

方法演示，程式碼如下：

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
        // 判斷是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
        System.out.println("d:\\aaa 是否存在:"+f2.exists());
        // 判斷是檔案還是目錄
        System.out.println("d:\\aaa 檔案?:"+f2.isFile());
        System.out.println("d:\\aaa 目錄?:"+f2.isDirectory());
    }
}
輸出結果：
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 檔案?:false
d:\aaa 目錄?:true

建立刪除功能的方法

• public boolean createNewFile() ：當且僅當具有該名稱的檔案尚不存在時，建立一個新的空檔案。
• public boolean delete() ：刪除由此File表示的檔案或目錄。
  
• public boolean mkdir() ：建立由此File表示的目錄。
• public boolean mkdirs() ：建立由此File表示的目錄，包括任何必需但不存在的父目錄。

方法演示，程式碼如下：

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 檔案的建立
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否建立:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
        
        // 目錄的建立
        File f2= new File("newDir");    
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否建立:"+f2.mkdir()); // true
        System.out.println("是否存在:"+f2.exists());// true

        // 建立多級目錄
        File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
        // 檔案的刪除
        System.out.println(f.delete());// true
      
        // 目錄的刪除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

API中說明：delete方法，如果此File表示目錄，則目錄必須為空才能刪除。

1.4 目錄的遍歷

• public String[] list() ：返回一個String陣列，表示該File目錄中的所有子檔案或目錄。

• public File[] listFiles() ：返回一個File陣列，表示該File目錄中的所有的子檔案或目錄。

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
        //獲取當前目錄下的檔案以及資料夾的名稱。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //獲取當前目錄下的檔案以及資料夾物件，只要拿到了檔案物件，那麼就可以獲取更多資訊
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

小貼士：

呼叫listFiles方法的File物件，表示的必須是實際存在的目錄，否則返回null，無法進行遍歷。

第二章 遞迴

2.1 概述

• 遞迴：指在當前方法內呼叫自己的這種現象。

• 遞迴的分類:
  • 遞迴分為兩種，直接遞迴和間接遞迴。
  • 直接遞迴稱為方法自身呼叫自己。
  • 間接遞迴可以A方法呼叫B方法，B方法呼叫C方法，C方法呼叫A方法。
• 注意事項：
  • 遞迴一定要有條件限定，保證遞迴能夠停止下來，否則會發生棧記憶體溢位。
  • 在遞迴中雖然有限定條件，但是遞迴次數不能太多。否則也會發生棧記憶體溢位。
  • 構造方法,禁止遞迴

public class Demo01DiGui {
    public static void main(String[] args) {
        // a();
        b(1);
    }
    
    /*
     * 3.構造方法,禁止遞迴
     * 編譯報錯:構造方法是建立物件使用的,不能讓物件一直建立下去
     */
    public Demo01DiGui() {
        //Demo01DiGui();
    }


    /*
     * 2.在遞迴中雖然有限定條件，但是遞迴次數不能太多。否則也會發生棧記憶體溢位。
     * 4993
     *  Exception in thread "main" java.lang.StackOverflowError
     */
    private static void b(int i) {
        System.out.println(i);
        //新增一個遞迴結束的條件,i==5000的時候結束
        if(i==5000){
            return;//結束方法
        }
        b(++i);
    }

    /*
     * 1.遞迴一定要有條件限定，保證遞迴能夠停止下來，否則會發生棧記憶體溢位。 Exception in thread "main"
     * java.lang.StackOverflowError
     */
    private static void a() {
        System.out.println("a方法");
        a();
    }
}

2.2 遞迴累加求和

計算1 ~ n的和

分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定義成一個方法，遞迴呼叫。

實現程式碼：

public class DiGuiDemo {
    public static void main(String[] args) {
        //計算1~num的和，使用遞迴完成
        int num = 5;
        // 呼叫求和的方法
        int sum = getSum(num);
        // 輸出結果
        System.out.println(sum);
        
    }
    /*
      通過遞迴演算法實現.
      引數列表:int 
      返回值型別: int 
    */
    public static int getSum(int num) {
        /* 
           num為1時,方法返回1,
           相當於是方法的出口,num總有是1的情況
        */
        if(num == 1){
            return 1;
        }
        /*
          num不為1時,方法返回 num +(num-1)的累和
          遞迴呼叫getSum方法
        */
        return num + getSum(num-1);
    }
}

程式碼執行圖解

小貼士：遞迴一定要有條件限定，保證遞迴能夠停止下來，次數不要太多，否則會發生棧記憶體溢位。

2.3 遞迴求階乘

• 階乘：所有小於及等於該數的正整數的積。

n的階乘：n! = n * (n-1) *...* 3 * 2 * 1 

分析：這與累和類似,只不過換成了乘法運算，學員可以自己練習，需要注意階乘值符合int型別的範圍。

推理得出：n! = n * (n-1)!

程式碼實現：

public class DiGuiDemo {
    //計算n的階乘，使用遞迴完成
    public static void main(String[] args) {
        int n = 3;
        // 呼叫求階乘的方法
        int value = getValue(n);
        // 輸出結果
        System.out.println("階乘為:"+ value);
    }
    /*
      通過遞迴演算法實現.
      引數列表:int 
      返回值型別: int 
    */
    public static int getValue(int n) {
        // 1的階乘為1
        if (n == 1) {
            return 1;
        }
        /*
          n不為1時,方法返回 n! = n*(n-1)!
          遞迴呼叫getValue方法
        */
        return n * getValue(n - 1);
    }
}

2.4 遞迴列印多級目錄

分析：多級目錄的列印，就是當目錄的巢狀。遍歷之前，無從知道到底有多少級目錄，所以我們還是要使用遞迴實現。

程式碼實現：

public class DiGuiDemo2 {
    public static void main(String[] args) {
        // 建立File物件
        File dir  = new File("D:\\aaa");
        // 呼叫列印目錄方法
        printDir(dir);
    }

    public static void  printDir(File dir) {
        // 獲取子檔案和目錄
        File[] files = dir.listFiles();
        // 迴圈列印
        /*
          判斷:
          當是檔案時,列印絕對路徑.
          當是目錄時,繼續呼叫列印目錄的方法,形成遞迴呼叫.
        */
        for (File file : files) {
            // 判斷
            if (file.isFile()) {
                // 是檔案,輸出檔案絕對路徑
                System.out.println("檔名:"+ file.getAbsolutePath());
            } else {
                // 是目錄,輸出目錄絕對路徑
                System.out.println("目錄:"+file.getAbsolutePath());
                // 繼續遍歷,呼叫printDir,形成遞迴
                printDir(file);
            }
        }
    }
}

第三章 綜合案例

3.1 檔案搜尋

搜尋D:\aaa 目錄中的.java 檔案。

分析：

1. 目錄搜尋，無法判斷多少級目錄，所以使用遞迴，遍歷所有目錄。
2. 遍歷目錄時，獲取的子檔案，通過檔名稱，判斷是否符合條件。

程式碼實現：

public class DiGuiDemo3 {
    public static void main(String[] args) {
        // 建立File物件
        File dir  = new File("D:\\aaa");
        // 呼叫列印目錄方法
        printDir(dir);
    }

    public static void printDir(File dir) {
        // 獲取子檔案和目錄
        File[] files = dir.listFiles();
        
        // 迴圈列印
        for (File file : files) {
            if (file.isFile()) {
                // 是檔案，判斷檔名並輸出檔案絕對路徑
                if (file.getName().endsWith(".java")) {
                    System.out.println("檔名:" + file.getAbsolutePath());
                }
            } else {
                // 是目錄，繼續遍歷,形成遞迴
                printDir(file);
            }
        }
    }
}

3.2 檔案過濾器優化

java.io.FileFilter是一個介面，是File的過濾器。 該介面的物件可以傳遞給File類的listFiles(FileFilter) 作為引數， 介面中只有一個方法。

boolean accept(File pathname) ：測試pathname是否應該包含在當前File目錄中，符合則返回true。

分析：

1. 介面作為引數，需要傳遞子類物件，重寫其中方法。我們選擇匿名內部類方式，比較簡單。
2. accept方法，引數為File，表示當前File下所有的子檔案和子目錄。保留住則返回true，過濾掉則返回false。保留規則：
   1. 要麼是.java檔案。
   2. 要麼是目錄，用於繼續遍歷。
3. 通過過濾器的作用，listFiles(FileFilter)返回的陣列元素中，子檔案物件都是符合條件的，可以直接列印。

程式碼實現：

public class DiGuiDemo4 {
    public static void main(String[] args) {
        File dir = new File("D:\\aaa");
        printDir2(dir);
    }
  
    public static void printDir2(File dir) {
        // 匿名內部類方式,建立過濾器子類物件
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".java")||pathname.isDirectory();
            }
        });
        // 迴圈列印
        for (File file : files) {
            if (file.isFile()) {
                System.out.println("檔名:" + file.getAbsolutePath());
            } else {
                printDir2(file);
            }
        }
    }
}      

3.3 Lambda優化

分析：FileFilter是隻有一個方法的介面，因此可以用lambda表示式簡寫。

lambda格式：

()->{ }

程式碼實現：

public static void printDir3(File dir) {
    // lambda的改寫
    File[] files = dir.listFiles(f ->{ 
        return f.getName().endsWith(".java") || f.isDirectory(); 
    });
    
    // 迴圈列印
    for (File file : files) {
        if (file.isFile()) {
            System.out.println("檔名:" + file.getAbsolutePath());
        } else {
            printDir3(file);
        }
    }
}

第四章 IO概述

4.1 什麼是IO

生活中，你肯定經歷過這樣的場景。當你編輯一個文字檔案，忘記了ctrl+s ，可能檔案就白白編輯了。當你電腦上插入一個U盤，可以把一個視訊，拷貝到你的電腦硬盤裡。那麼資料都是在哪些裝置上的呢？鍵盤、記憶體、硬碟、外接裝置等等。

我們把這種資料的傳輸，可以看做是一種資料的流動，按照流動的方向，以記憶體為基準，分為輸入input 和輸出output ，即流向記憶體是輸入流，流出記憶體的輸出流。

Java中I/O操作主要是指使用java.io包下的內容，進行輸入、輸出操作。輸入也叫做讀取資料，輸出也叫做作寫出資料。

4.2 IO的分類

根據資料的流向分為：輸入流和輸出流。

• 輸入流 ：把資料從其他裝置上讀取到記憶體中的流。
• 輸出流 ：把資料從記憶體 中寫出到其他裝置上的流。

格局資料的型別分為：位元組流和字元流。

• 位元組流 ：以位元組為單位，讀寫資料的流。
• 字元流 ：以字元為單位，讀寫資料的流。

4.3 IO的流向說明圖解

4.4 頂級父類們

第五章 位元組流

5.1 一切皆為位元組

一切檔案資料(文字、圖片、視訊等)在儲存時，都是以二進位制數字的形式儲存，都一個一個的位元組，那麼傳輸時一樣如此。所以，位元組流可以傳輸任意檔案資料。在操作流的時候，我們要時刻明確，無論使用什麼樣的流物件，底層傳輸的始終為二進位制資料。

5.2 位元組輸出流【OutputStream】

java.io.OutputStream抽象類是表示位元組輸出流的所有類的超類，將指定的位元組資訊寫出到目的地。它定義了位元組輸出流的基本共性功能方法。

• public void close() ：關閉此輸出流並釋放與此流相關聯的任何系統資源。
  
• public void flush() ：重新整理此輸出流並強制任何緩衝的輸出位元組被寫出。
  
• public void write(byte[] b)：將 b.length位元組從指定的位元組陣列寫入此輸出流。
  
• public void write(byte[] b, int off, int len) ：從指定的位元組陣列寫入 len位元組，從偏移量 off開始輸出到此輸出流。
  
• public abstract void write(int b) ：將指定的位元組輸出流。

小貼士：

close方法，當完成流的操作時，必須呼叫此方法，釋放系統資源。

5.3 FileOutputStream類

OutputStream有很多子類，我們從最簡單的一個子類開始。

java.io.FileOutputStream類是檔案輸出流，用於將資料寫出到檔案。

構造方法

• public FileOutputStream(File file)：建立檔案輸出流以寫入由指定的 File物件表示的檔案。
• public FileOutputStream(String name)： 建立檔案輸出流以指定的名稱寫入檔案。

當你建立一個流物件時，必須傳入一個檔案路徑。該路徑下，如果沒有這個檔案，會建立該檔案。如果有這個檔案，會清空這個檔案的資料。

• 構造舉例，程式碼如下：

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
        // 使用File物件建立流物件
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

寫出位元組資料

1. 寫出位元組：write(int b) 方法，每次可以寫出一個位元組資料，程式碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 寫出資料
        fos.write(97); // 寫出第1個位元組
        fos.write(98); // 寫出第2個位元組
        fos.write(99); // 寫出第3個位元組
        // 關閉資源
        fos.close();
    }
}
輸出結果：
abc

小貼士：

1. 雖然引數為int型別四個位元組，但是隻會保留一個位元組的資訊寫出。
2. 流操作完畢後，必須釋放系統資源，呼叫close方法，千萬記得。

1. 寫出位元組陣列：write(byte[] b)，每次可以寫出陣列中的資料，程式碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 字串轉換為位元組陣列
        byte[] b = "Java程式設計師".getBytes();
        // 寫出位元組陣列資料
        fos.write(b);
        // 關閉資源
        fos.close();
    }
}
輸出結果：
Java程式設計師

1. 寫出指定長度位元組陣列：write(byte[] b, int off, int len) ,每次寫出從off索引開始，len個位元組，程式碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 字串轉換為位元組陣列
        byte[] b = "abcde".getBytes();
        // 寫出從索引2開始，2個位元組。索引2是c，兩個位元組，也就是cd。
        fos.write(b,2,2);
        // 關閉資源
        fos.close();
    }
}
輸出結果：
cd

資料追加續寫

經過以上的演示，每次程式執行，建立輸出流物件，都會清空目標檔案中的資料。如何保留目標檔案中資料，還能繼續新增新資料呢？

• public FileOutputStream(File file, boolean append)： 建立檔案輸出流以寫入由指定的 File物件表示的檔案。
  
• public FileOutputStream(String name, boolean append)： 建立檔案輸出流以指定的名稱寫入檔案。

這兩個構造方法，引數中都需要傳入一個boolean型別的值，true 表示追加資料，false 表示清空原有資料。這樣建立的輸出流物件，就可以指定是否追加續寫了，程式碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
        // 字串轉換為位元組陣列
        byte[] b = "abcde".getBytes();
        // 寫出從索引2開始，2個位元組。索引2是c，兩個位元組，也就是cd。
        fos.write(b);
        // 關閉資源
        fos.close();
    }
}
檔案操作前：cd
檔案操作後：cdabcde

寫出換行

Windows系統裡，換行符號是\r\n 。

程式碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileOutputStream fos = new FileOutputStream("fos.txt");  
        // 定義位元組陣列
        byte[] words = {97,98,99,100,101};
        // 遍歷陣列
        for (int i = 0; i < words.length; i++) {
            // 寫出一個位元組
            fos.write(words[i]);
            // 寫出一個換行, 換行符號轉成陣列寫出
            fos.write("\r\n".getBytes());
        }
        // 關閉資源
        fos.close();
    }
}

輸出結果：
a
b
c
d
e

• 回車符\r和換行符\n ：
  • 回車符：回到一行的開頭（return）。
  • 換行符：下一行（newline）。
• 系統中的換行：
  • Windows系統裡，每行結尾是 回車+換行 ，即\r\n；
  • Unix系統裡，每行結尾只有 換行 ，即\n；
  • Mac系統裡，每行結尾是 回車 ，即\r。從 Mac OS X開始與Linux統一。

5.4 位元組輸入流【InputStream】

java.io.InputStream抽象類是表示位元組輸入流的所有類的超類，可以讀取位元組資訊到記憶體中。它定義了位元組輸入流的基本共性功能方法。

• public void close() ：關閉此輸入流並釋放與此流相關聯的任何系統資源。
  
• public abstract int read()： 從輸入流讀取資料的下一個位元組。
• public int read(byte[] b)： 從輸入流中讀取一些位元組數，並將它們儲存到位元組陣列 b中 。

小貼士：

close方法，當完成流的操作時，必須呼叫此方法，釋放系統資源。

5.5 FileInputStream類

java.io.FileInputStream類是檔案輸入流，從檔案中讀取位元組。

構造方法

• FileInputStream(File file)： 通過開啟與實際檔案的連線來建立一個 FileInputStream ，該檔案由檔案系統中的 File物件 file命名。
• FileInputStream(String name)： 通過開啟與實際檔案的連線來建立一個 FileInputStream ，該檔案由檔案系統中的路徑名 name命名。

當你建立一個流物件時，必須傳入一個檔案路徑。該路徑下，如果沒有該檔案,會丟擲FileNotFoundException 。

• 構造舉例，程式碼如下：

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
        // 使用File物件建立流物件
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用檔名稱建立流物件
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

讀取位元組資料

1. 讀取位元組：read方法，每次可以讀取一個位元組的資料，提升為int型別，讀取到檔案末尾，返回-1，程式碼使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用檔名稱建立流物件
        FileInputStream fis = new FileInputStream("read.txt");
        // 讀取資料，返回一個位元組
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        // 讀取到末尾,返回-1
        read = fis.read();
        System.out.println( read);
        // 關閉資源
        fis.close();
    }
}
輸出結果：
a
b
c
d
e
-1

迴圈改進讀取方式，程式碼使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用檔名稱建立流物件
        FileInputStream fis = new FileInputStream("read.txt");
        // 定義變數，儲存資料
        int b ；
        // 迴圈讀取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
        // 關閉資源
        fis.close();
    }
}
輸出結果：
a
b
c
d
e

小貼士：

1. 雖然讀取了一個位元組，但是會自動提升為int型別。
2. 流操作完畢後，必須釋放系統資源，呼叫close方法，千萬記得。

1. 使用位元組陣列讀取：read(byte[] b)，每次讀取b的長度個位元組到陣列中，返回讀取到的有效位元組個數，讀取到末尾時，返回-1 ，程式碼使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用檔名稱建立流物件.
        FileInputStream fis = new FileInputStream("read.txt"); // 檔案中為abcde
        // 定義變數，作為有效個數
        int len ；
        // 定義位元組陣列，作為裝位元組資料的容器   
        byte[] b = new byte[2];
        // 迴圈讀取
        while (( len= fis.read(b))!=-1) {
            // 每次讀取後,把陣列變成字串列印
            System.out.println(new String(b));
        }
        // 關閉資源
        fis.close();
    }
}

輸出結果：
ab
cd
ed

錯誤資料d，是由於最後一次讀取時，只讀取一個位元組e，陣列中，上次讀取的資料沒有被完全替換，所以要通過len ，獲取有效的位元組，程式碼使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用檔名稱建立流物件.
        FileInputStream fis = new FileInputStream("read.txt"); // 檔案中為abcde
        // 定義變數，作為有效個數
        int len ；
        // 定義位元組陣列，作為裝位元組資料的容器   
        byte[] b = new byte[2];
        // 迴圈讀取
        while (( len= fis.read(b))!=-1) {
            // 每次讀取後,把陣列的有效位元組部分，變成字串列印
            System.out.println(new String(b，0，len));//  len 每次讀取的有效位元組個數
        }
        // 關閉資源
        fis.close();
    }
}

輸出結果：
ab
cd
e

小貼士：

使用陣列讀取，每次讀取多個位元組，減少了系統間的IO操作次數，從而提高了讀寫的效率，建議開發中使用。

5.6 位元組流練習：圖片複製

複製原理圖解

案例實現

複製圖片檔案，程式碼使用演示：

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.建立流物件
        // 1.1 指定資料來源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");

        // 2.讀寫資料
        // 2.1 定義陣列
        byte[] b = new byte[1024];
        // 2.2 定義長度
        int len;
        // 2.3 迴圈讀取
        while ((len = fis.read(b))!=-1) {
            // 2.4 寫出資料
            fos.write(b, 0 , len);
        }

        // 3.關閉資源
        fos.close();
        fis.close();
    }
}

小貼士：

流的關閉原則：先開後關，後開先關。

第六章 字元流

當使用位元組流讀取文字檔案時，可能會有一個小問題。就是遇到中文字元時，可能不會顯示完整的字元，那是因為一箇中文字元可能佔用多個位元組儲存。所以Java提供一些字元流類，以字元為單位讀寫資料，專門用於處理文字檔案。

6.1 字元輸入流【Reader】

java.io.Reader抽象類是表示用於讀取字元流的所有類的超類，可以讀取字元資訊到記憶體中。它定義了字元輸入流的基本共性功能方法。

• public void close() ：關閉此流並釋放與此流相關聯的任何系統資源。
  
• public int read()： 從輸入流讀取一個字元。
• public int read(char[] cbuf)： 從輸入流中讀取一些字元，並將它們儲存到字元陣列 cbuf中 。

6.2 FileReader類

java.io.FileReader類是讀取字元檔案的便利類。構造時使用系統預設的字元編碼和預設位元組緩衝區。

小貼士：

1. 字元編碼：位元組與字元的對應規則。Windows系統的中文編碼預設是GBK編碼表。

   idea中UTF-8

2. 位元組緩衝區：一個位元組陣列，用來臨時儲存位元組資料。

構造方法

• FileReader(File file)： 建立一個新的 FileReader ，給定要讀取的File物件。
  
• FileReader(String fileName)： 建立一個新的 FileReader ，給定要讀取的檔案的名稱。

當你建立一個流物件時，必須傳入一個檔案路徑。類似於FileInputStream 。

• 構造舉例，程式碼如下：

public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
        // 使用File物件建立流物件
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用檔名稱建立流物件
        FileReader fr = new FileReader("b.txt");
    }
}

讀取字元資料

1. 讀取字元：read方法，每次可以讀取一個字元的資料，提升為int型別，讀取到檔案末尾，返回-1，迴圈讀取，程式碼使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileReader fr = new FileReader("read.txt");
        // 定義變數，儲存資料
        int b ；
        // 迴圈讀取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
        // 關閉資源
        fr.close();
    }
}
輸出結果：
中
文
樣
例
一

小貼士：雖然讀取了一個字元，但是會自動提升為int型別。

1. 使用字元陣列讀取：read(char[] cbuf)，每次讀取b的長度個字元到陣列中，返回讀取到的有效字元個數，讀取到末尾時，返回-1 ，程式碼使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileReader fr = new FileReader("read.txt");
        // 定義變數，儲存有效字元個數
        int len ；
        // 定義字元陣列，作為裝字元資料的容器
         char[] cbuf = new char[2];
        // 迴圈讀取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
        // 關閉資源
        fr.close();
    }
}
輸出結果：
中文
樣例
一例

獲取有效的字元改進，程式碼使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileReader fr = new FileReader("read.txt");
        // 定義變數，儲存有效字元個數
        int len ；
        // 定義字元陣列，作為裝字元資料的容器
        char[] cbuf = new char[2];
        // 迴圈讀取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
        // 關閉資源
        fr.close();
    }
}

輸出結果：
中文
樣例
一

6.3 字元輸出流【Writer】

java.io.Writer抽象類是表示用於寫出字元流的所有類的超類，將指定的字元資訊寫出到目的地。它定義了位元組輸出流的基本共性功能方法。

• void write(int c) 寫入單個字元。
• void write(char[] cbuf)寫入字元陣列。
• abstract void write(char[] cbuf, int off, int len)寫入字元陣列的某一部分,off陣列的開始索引,len寫的字元個數。
• void write(String str)寫入字串。
• void write(String str, int off, int len) 寫入字串的某一部分,off字串的開始索引,len寫的字元個數。
• void flush()重新整理該流的緩衝。
  
• void close() 關閉此流，但要先重新整理它。

6.4 FileWriter類

java.io.FileWriter類是寫出字元到檔案的便利類。構造時使用系統預設的字元編碼和預設位元組緩衝區。

構造方法

• FileWriter(File file)： 建立一個新的 FileWriter，給定要讀取的File物件。
  
• FileWriter(String fileName)： 建立一個新的 FileWriter，給定要讀取的檔案的名稱。

當你建立一個流物件時，必須傳入一個檔案路徑，類似於FileOutputStream。

• 構造舉例，程式碼如下：

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
        // 使用File物件建立流物件
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用檔名稱建立流物件
        FileWriter fw = new FileWriter("b.txt");
    }
}

基本寫出資料

寫出字元：write(int b) 方法，每次可以寫出一個字元資料，程式碼使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileWriter fw = new FileWriter("fw.txt");     
        // 寫出資料
        fw.write(97); // 寫出第1個字元
        fw.write('b'); // 寫出第2個字元
        fw.write('C'); // 寫出第3個字元
        fw.write(30000); // 寫出第4個字元，中文編碼表中30000對應一個漢字。
      
        /*
        【注意】關閉資源時,與FileOutputStream不同。
         如果不關閉,資料只是儲存到緩衝區，並未儲存到檔案。
        */
        // fw.close();
    }
}
輸出結果：
abC田

小貼士：

1. 雖然引數為int型別四個位元組，但是隻會保留一個字元的資訊寫出。
2. 未呼叫close方法，資料只是儲存到了緩衝區，並未寫出到檔案中。

關閉和重新整理

因為內建緩衝區的原因，如果不關閉輸出流，無法寫出字元到檔案中。但是關閉的流物件，是無法繼續寫出資料的。如果我們既想寫出資料，又想繼續使用流，就需要flush 方法了。

• flush ：重新整理緩衝區，流物件可以繼續使用。
• close:先重新整理緩衝區，然後通知系統釋放資源。流物件不可以再被使用了。

程式碼使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileWriter fw = new FileWriter("fw.txt");
        // 寫出資料，通過flush
        fw.write('刷'); // 寫出第1個字元
        fw.flush();
        fw.write('新'); // 繼續寫出第2個字元，寫出成功
        fw.flush();
      
        // 寫出資料，通過close
        fw.write('關'); // 寫出第1個字元
        fw.close();
        fw.write('閉'); // 繼續寫出第2個字元,【報錯】java.io.IOException: Stream closed
        fw.close();
    }
}

小貼士：即便是flush方法寫出了資料，操作的最後還是要呼叫close方法，釋放系統資源。

寫出其他資料

1. 寫出字元陣列 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以寫出字元陣列中的資料，用法類似FileOutputStream，程式碼使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileWriter fw = new FileWriter("fw.txt");     
        // 字串轉換為位元組陣列
        char[] chars = "JAVA程式設計師".toCharArray();
      
        // 寫出字元陣列
        fw.write(chars); // JAVA程式設計師
        
        // 寫出從索引2開始，2個位元組。索引2是'V'，兩個位元組，也就是'VA'。
        fw.write(chars,2,2); // VA
      
        // 關閉資源
        fw.close();
    }
}

1. 寫出字串：write(String str) 和 write(String str, int off, int len) ，每次可以寫出字串中的資料，更為方便，程式碼使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件
        FileWriter fw = new FileWriter("fw.txt");     
        // 字串
        String msg = "JAVA程式設計師";
      
        // 寫出字元陣列
        fw.write(msg); //JAVA程式設計師
      
        // 寫出從索引2開始，2個位元組。索引2是'V'，兩個位元組，也就是'VA'。
        fw.write(msg,2,2);  // VA
        
        // 關閉資源
        fw.close();
    }
}

1. 續寫和換行：操作類似於FileOutputStream。

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用檔名稱建立流物件，可以續寫資料
        FileWriter fw = new FileWriter("fw.txt"，true);     
        // 寫出字串
        fw.write("JAVA");
        // 寫出換行
        fw.write("\r\n");
        // 寫出字串
        fw.write("程式設計師");
        // 關閉資源
        fw.close();
    }
}
輸出結果:
JAVA
程式設計師

小貼士：字元流，只能操作文字檔案，不能操作圖片，視訊等非文字檔案。

當我們單純讀或者寫文字檔案時 使用字元流 其他情況使用位元組流

第七章 IO異常的處理

JDK7前處理

之前的入門練習，我們一直把異常丟擲，而實際開發中並不能這樣處理，建議使用try...catch...finally 程式碼塊，處理異常部分，程式碼使用演示：

public class HandleException1 {
    public static void main(String[] args) {
        // 宣告變數
        FileWriter fw = null;
        try {
            //建立流物件
            fw = new FileWriter("fw.txt");
            // 寫出資料
            fw.write("JAVA程式設計師"); //JAVA程式設計師
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7的處理(擴充套件知識點了解內容)

還可以使用JDK7優化後的try-with-resource 語句，該語句確保了每個資源在語句結束時關閉。所謂的資源（resource）是指在程式完成後，必須關閉的物件。

格式：

try (建立流物件語句，如果多個,使用';'隔開) {
    // 讀寫資料
} catch (IOException e) {
    e.printStackTrace();
}

程式碼使用演示：

public class HandleException2 {
    public static void main(String[] args) {
        // 建立流物件
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 寫出資料
            fw.write("JAVA程式設計師"); //JAVA程式設計師
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9的改進(擴充套件知識點了解內容)

JDK9中try-with-resource 的改進，對於引入物件的方式，支援的更加簡潔。被引入的物件，同樣可以自動關閉，無需手動close，我們來了解一下格式。

改進前格式：

// 被final修飾的物件
final Resource resource1 = new Resource("resource1");
// 普通物件
Resource resource2 = new Resource("resource2");
// 引入方式：建立新的變數儲存
try (Resource r1 = resource1;
     Resource r2 = resource2) {
     // 使用物件
}

改進後格式：

// 被final修飾的物件
final Resource resource1 = new Resource("resource1");
// 普通物件
Resource resource2 = new Resource("resource2");

// 引入方式：直接引入
try (resource1; resource2) {
     // 使用物件
}

改進後，程式碼使用演示：

public class TryDemo {
    public static void main(String[] args) throws IOException {
        // 建立流物件
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
        // 引入到try中
        try (fr; fw) {
            // 定義變數
            int b;
            // 讀取資料
            while ((b = fr.read())!=-1) {
                // 寫出資料
                fw.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

第八章 屬性集

8.1 概述

java.util.Properties 繼承於Hashtable ，來表示一個持久的屬性集。它使用鍵值結構儲存資料，每個鍵及其對應值都是一個字串。該類也被許多Java類使用，比如獲取系統屬性時，System.getProperties 方法就是返回一個Properties物件。

8.2 Properties類

構造方法

• public Properties() :建立一個空的屬性列表。

基本的儲存方法

• public Object setProperty(String key, String value) ： 儲存一對屬性。
  
• public String getProperty(String key) ：使用此屬性列表中指定的鍵搜尋屬性值。
• public Set<String> stringPropertyNames() ：所有鍵的名稱的集合。

public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 建立屬性集物件
        Properties properties = new Properties();
        // 新增鍵值對元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 列印屬性集物件
        System.out.println(properties);
        // 通過鍵,獲取屬性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍歷屬性集,獲取所有鍵的集合
        Set<String> strings = properties.stringPropertyNames();
        // 列印鍵值對
        for (String key : strings ) {
            System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
輸出結果：
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt

與流相關的方法

• public void load(InputStream inStream)： 從位元組輸入流中讀取鍵值對。

引數中使用了位元組輸入流，通過流物件，可以關聯到某檔案上，這樣就能夠載入文字中的資料了。文字資料格式:

filename=a.txt
length=209385038
location=D:\a.txt

載入程式碼演示：

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 建立屬性集物件
        Properties pro = new Properties();
        // 載入文字中資訊到屬性集
        pro.load(new FileInputStream("read.txt"));
        // 遍歷集合並列印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
            System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
輸出結果：
filename -- a.txt
length -- 209385038
location -- D:\a.txt

小貼士：文字中的資料，必須是鍵值對形式，可以使用空格、等號、冒號等符號分隔。

第九章 緩衝流

上面學習了基本的一些流，作為IO流的入門，接下來我們要見識一些更強大的流。比如能夠高效讀寫的緩衝流，能夠轉換編碼的轉換流，能夠持久化儲存物件的序列化流等等。這些功能更為強大的流，都是在基本的流物件基礎之上建立而來的，就像穿上鎧甲的武士一樣，相當於是對基本流物件的一種增強。

9.1 概述

緩衝流,也叫高效流，是對4個基本的FileXxx 流的增強，所以也是4個流，按照資料型別分類：

• 位元組緩衝流：BufferedInputStream，BufferedOutputStream
• 字元緩衝流：BufferedReader，BufferedWriter

緩衝流的基本原理，是在建立流物件時，會建立一個內建的預設大小的緩衝區陣列，通過緩衝區讀寫，減少系統IO次數，從而提高讀寫的效率。

9.2 位元組緩衝流

構造方法

• public BufferedInputStream(InputStream in) ：建立一個 新的緩衝輸入流。
• public BufferedOutputStream(OutputStream out)： 建立一個新的緩衝輸出流。

構造舉例，程式碼如下：

// 建立位元組緩衝輸入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 建立位元組緩衝輸出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率測試

查詢API，緩衝流讀寫方法與基本的流是一致的，我們通過複製大檔案（375MB），測試它的效率。

1. 基本流，程式碼如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 記錄開始時間
        long start = System.currentTimeMillis();
        // 建立流物件
        try (
            FileInputStream fis = new FileInputStream("jdk9.exe");
            FileOutputStream fos = new FileOutputStream("copy.exe")
        ){
            // 讀寫資料
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }
}

十幾分鍾過去了...

1. 緩衝流，程式碼如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 記錄開始時間
        long start = System.currentTimeMillis();
        // 建立流物件
        try (
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
        // 讀寫資料
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("緩衝流複製時間:"+(end - start)+" 毫秒");
    }
}

緩衝流複製時間:8016 毫秒

如何更快呢？

使用陣列的方式，程式碼如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 記錄開始時間
        long start = System.currentTimeMillis();
        // 建立流物件
        try (
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
            // 讀寫資料
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("緩衝流使用陣列複製時間:"+(end - start)+" 毫秒");
    }
}
緩衝流使用陣列複製時間:666 毫秒

9.3 字元緩衝流

構造方法

• public BufferedReader(Reader in) ：建立一個 新的緩衝輸入流。
• public BufferedWriter(Writer out)： 建立一個新的緩衝輸出流。

構造舉例，程式碼如下：

// 建立字元緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 建立字元緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字元緩衝流的基本方法與普通字元流呼叫方式一致，不再闡述，我們來看它們具備的特有方法。

• BufferedReader：public String readLine(): 讀一行文字。
• BufferedWriter：public void newLine(): 寫一行行分隔符,由系統屬性定義符號。

readLine方法演示，程式碼如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
         // 建立流物件
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        // 定義字串,儲存讀取的一行文字
        String line  = null;
        // 迴圈讀取,讀取到最後返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
        // 釋放資源
        br.close();
    }
}

newLine方法演示，程式碼如下：

public class BufferedWriterDemo throws IOException {
  public static void main(String[] args) throws IOException  {
      // 建立流物件
      BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
      // 寫出資料
      bw.write("JAVA");
      // 寫出換行
      bw.newLine();
      bw.write("程式");
      bw.newLine();
      bw.write("員");
      bw.newLine();
      // 釋放資源
      bw.close();
  }
}
輸出效果:
JAVA
程式
員

9.4 練習:文字排序

請將文字資訊恢復順序。

3.侍中、侍郎郭攸之、費禕、董允等，此皆良實，志慮忠純，是以先帝簡拔以遺陛下。愚以為宮中之事，事無大小，悉以諮之，然後施行，必得裨補闕漏，有所廣益。
8.願陛下託臣以討賊興復之效，不效，則治臣之罪，以告先帝之靈。若無興德之言，則責攸之、禕、允等之慢，以彰其咎；陛下亦宜自謀，以諮諏善道，察納雅言，深追先帝遺詔，臣不勝受恩感激。
4.將軍向寵，性行淑均，曉暢軍事，試用之於昔日，先帝稱之曰能，是以眾議舉寵為督。愚以為營中之事，悉以諮之，必能使行陣和睦，優劣得所。
2.宮中府中，俱為一體，陟罰臧否，不宜異同。若有作奸犯科及為忠善者，宜付有司論其刑賞，以昭陛下平明之理，不宜偏私，使內外異法也。
1.先帝創業未半而中道崩殂，今天下三分，益州疲弊，此誠危急存亡之秋也。然侍衛之臣不懈於內，忠志之士忘身於外者，蓋追先帝之殊遇，欲報之於陛下也。誠宜開張聖聽，以光先帝遺德，恢弘志士之氣，不宜妄自菲薄，引喻失義，以塞忠諫之路也。
9.今當遠離，臨表涕零，不知所言。
6.臣本布衣，躬耕於南陽，苟全性命於亂世，不求聞達於諸侯。先帝不以臣卑鄙，猥自枉屈，三顧臣於草廬之中，諮臣以當世之事，由是感激，遂許先帝以驅馳。後值傾覆，受任於敗軍之際，奉命於危難之間，爾來二十有一年矣。
7.先帝知臣謹慎，故臨崩寄臣以大事也。受命以來，夙夜憂嘆，恐付託不效，以傷先帝之明，故五月渡瀘，深入不毛。今南方已定，兵甲已足，當獎率三軍，北定中原，庶竭駑鈍，攘除奸凶，興復漢室，還於舊都。此臣所以報先帝而忠陛下之職分也。至於斟酌損益，進盡忠言，則攸之、禕、允之任也。
5.親賢臣，遠小人，此先漢所以興隆也；親小人，遠賢臣，此後漢所以傾頹也。先帝在時，每與臣論此事，未嘗不嘆息痛恨於桓、靈也。侍中、尚書、長史、參軍，此悉貞良死節之臣，願陛下親之信之，則漢室之隆，可計日而待也。

案例分析

1. 逐行讀取文字資訊。
2. 解析文字資訊到集合中。
3. 遍歷集合，按順序