JavaSE學習筆記（14）---File類和IO流（位元組流和字元流）

JavaSE學習筆記（14） File類和IO流（位元組流和字元流） File類概述類是文件和目錄路徑名的抽象表示，主要用於文件和目錄的創建、查找和刪除等操作。構造方法：通過將給定的路徑名字元串轉換為抽象路徑名來創建新的 File實例。：從父路徑名字元串和子路徑名字元串創建新的 Fi ...

JavaSE學習筆記（14）---File類和IO流（位元組流和字元流）

File類

概述

java.io.File 類是文件和目錄路徑名的抽象表示，主要用於文件和目錄的創建、查找和刪除等操作。

構造方法

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);

小貼士：

一個File對象代表硬碟中實際存在的一個文件或者目錄。

無論該路徑下是否存在文件或者目錄，都不影響File對象的創建。

常用方法

獲取功能的方法

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表示目錄，則目錄必須為空才能刪除。

目錄的遍歷

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，無法進行遍歷。

IO概述

什麼是IO

生活中，你肯定經歷過這樣的場景。當你編輯一個文本文件，忘記了ctrl+s ，可能文件就白白編輯了。當你電腦上插入一個U盤，可以把一個視頻，拷貝到你的電腦硬碟里。那麼數據都是在哪些設備上的呢？鍵盤、記憶體、硬碟、外接設備等等。

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

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

IO的分類

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

輸入流 ：把數據從其他設備上讀取到記憶體中的流。
輸出流 ：把數據從記憶體 中寫出到其他設備上的流。

格局數據的類型分為：位元組流和字元流。

位元組流 ：以位元組為單位，讀寫數據的流。
字元流 ：以字元為單位，讀寫數據的流。

IO的流向說明

輸入：硬碟到記憶體
輸出：記憶體到硬碟

頂級父類們

	輸入流	輸出流
位元組流	位元組輸入流 InputStream	位元組輸出流 OutputStream
字元流	字元輸入流 Reader	字元輸出流 Writer

位元組流

一切皆為位元組

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

位元組輸出流【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方法，當完成流的操作時，必須調用此方法，釋放系統資源。

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");
    }
}

寫出位元組數據

寫出位元組：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

小貼士：

雖然參數為int類型四個位元組，但是只會保留一個位元組的信息寫出。

流操作完畢後，必須釋放系統資源，調用close方法，千萬記得。

寫出位元組數組：write(byte[] b)，每次可以寫出數組中的數據，代碼使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 字元串轉換為位元組數組
        byte[] b = "一二三四五六".getBytes();
        // 寫出位元組數組數據
        fos.write(b);
        // 關閉資源
        fos.close();
    }
}
輸出結果：
一二三四五六

寫出指定長度位元組數組：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統一。

位元組輸入流【InputStream】

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

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

小貼士：

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

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");
    }
}

讀取位元組數據

讀取位元組：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

小貼士：

雖然讀取了一個位元組，但是會自動提升為int類型。

流操作完畢後，必須釋放系統資源，調用close方法，千萬記得。

使用位元組數組讀取：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操作次數，從而提高了讀寫的效率，建議開發中使用。

位元組流練習：圖片複製

複製原理圖解

案例實現

複製圖片文件，代碼使用演示：

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提供一些字元流類，以字元為單位讀寫數據，專門用於處理文本文件。

字元輸入流【Reader】

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

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

FileReader類

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

小貼士：

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

idea中UTF-8

位元組緩衝區：一個位元組數組，用來臨時存儲位元組數據。

構造方法

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");
    }
}

讀取字元數據

read.txt里是“一二三四五”

讀取字元：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類型。

使用字元數組讀取：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();
    }
}

輸出結果：
一二
三四
五

字元輸出流【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() 關閉此流，但要先刷新它。

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田

小貼士：

雖然參數為int類型四個位元組，但是只會保留一個字元的信息寫出。

未調用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方法，釋放系統資源。

寫出其他數據

寫出字元數組 ：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 = "黑馬程式員".toCharArray();
      
        // 寫出字元數組
        fw.write(chars); // 黑馬程式員
        
        // 寫出從索引2開始，2個位元組。索引2是'程'，兩個位元組，也就是'程式'。
        fw.write(b,2,2); // 程式
      
        // 關閉資源
        fos.close();
    }
}

寫出字元串：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 = "黑馬程式員";
      
        // 寫出字元數組
        fw.write(msg); //黑馬程式員
      
        // 寫出從索引2開始，2個位元組。索引2是'程'，兩個位元組，也就是'程式'。
        fw.write(msg,2,2);  // 程式
        
        // 關閉資源
        fos.close();
    }
}

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

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象，可以續寫數據
        FileWriter fw = new FileWriter("fw.txt"，true);     
        // 寫出字元串
        fw.write("黑馬");
        // 寫出換行
        fw.write("\r\n");
        // 寫出字元串
        fw.write("程式員");
        // 關閉資源
        fw.close();
    }
}
輸出結果:
黑馬
程式員

小貼士：字元流，只能操作文本文件，不能操作圖片，視頻等非文本文件。

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

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("黑馬程式員"); //黑馬程式員
        } 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("黑馬程式員"); //黑馬程式員
        } 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();
        }
    }
}

屬性集

概述

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

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

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