總結

IO概述

什麼是IO

生活中，你肯定經歷過這樣的場景。當你編輯一個文字檔案，忘記了ctrl+s ，可能檔案就白白編輯了。當你電腦上插入一個U盤，可以把一個視訊，拷貝到你的電腦硬盤裡。那麼資料都是在哪些裝置上的呢？鍵盤、記憶體、硬碟、外接裝置等等。我們把這種資料的傳輸，可以看做是一種資料的流動，按照流動的方向，以記憶體為基準，分為輸入input 和輸出output ，即流向記憶體是輸入流，流出記憶體的輸出流。
Java中I/O操作主要是指使用java.io包下的內容，進行輸入、輸出操作。輸入也叫做讀取資料，輸出也叫做作寫出資料。

IO的分類

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

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

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

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

IO的流向說明圖解

1.4 頂級父類們

File類

概述

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

構造方法

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

package IO.File類.demo01;
/**測試構造方法**/
import java.io.File;
public class FileTest {
    public static void main(String[] args) {
        /*檔案路徑名*/
        String pathname = "E:\\CodePlace\\Java\\idea\\狂神說Java\\JavaSE\\a.txt";
        File file = new File(pathname);
        
        /*父路徑+子路徑*/
        String parent = "E:\\CodePlace\\Java\\idea\\狂神說Java\\JavaSE";
        String child = "a.txt";
        File file1 = new File(parent,child);
        
        /*父級物件和子路徑*/
        File parentDir = new File("E:\\CodePlace\\Java\\idea\\狂神說Java\\JavaSE");
        child = "a.txt";
        File file2 = new File(parentDir,child);
    }
}
 

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

常用方法

獲取功能的方法

• public String getAbsolutePath() ：返回此File的絕對路徑名字串。
  
• public String getPath() ：將此File轉換為路徑名字串。
  
• public String getName() ：返回由此File表示的檔案或目錄的名稱。
  
• public long length() ：返回由此File表示的檔案的長度。
  方法演示，程式碼如下：

package IO.File類.demo01;

import java.io.File;

public class FileMethodTest {
    public static void main(String[] args) {
        File file = new File("E:\\CodePlace\\Java\\idea\\狂神說Java\\JavaSE\\基礎語法\\src\\IO\\File類\\demo01\\a.txt");
        //絕對路徑名
        System.out.println(file.getAbsolutePath());
        //將file轉換為路徑名字字元
        System.out.println(file.getPath());
        //檔名
        System.out.println(file.getName());
        //長度
        System.out.println(file.length());

    }
}


E:\CodePlace\Java\idea\狂神說Java\JavaSE\基礎語法\src\IO\File類\demo01\a.txt
E:\CodePlace\Java\idea\狂神說Java\JavaSE\基礎語法\src\IO\File類\demo01\a.txt
a.txt
26

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表示的是否為檔案。
  

方法演示，程式碼如下：

package IO.File類.demo01;

import java.io.File;

public class FileIS {
    public static void main(String[] args) {
        File f = new File("E:\\Data\\1\\income.xlsx");
        System.out.println(f.exists());
        System.out.println(f.isFile());
        System.out.println(f.isDirectory());
        System.out.println(f.length());
    }
}

建立刪除功能的方法

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

方法演示，程式碼如下：

package IO.File類.demo01;

import java.io.File;
import java.io.IOException;

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {

        File f = new File("E:\\Data\\1\\income2.xlsx");

        if(f.exists()){
            f.delete();
        }
        System.out.println(f.exists());

        if(!f.exists()){
            f.createNewFile();
        }
        System.out.println(f.exists());

        File f2 = new File("E:\\Data\\1\\income");
        if(!f2.exists()){
            f2.mkdir();
        }
        if(f2.exists()){
            f2.delete();
        }
    }
}

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

目錄的遍歷

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

package IO.File類.demo02;

import java.io.File;

public class DiGuiFileFor {
    public static void main(String[] args) {
        File dir = new File("E:\\Data");
        printDir(dir);
    }
    public static void printDir(File dir){
        File[] files = dir.listFiles();
        for(File file: files){
            if(file.isFile()){	//是檔案
                System.out.println(file.getAbsoluteFile());	//輸出檔案
            }else {	//是目錄，進入遞迴
                printDir(file);
            }
        }
    }
}

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

位元組流

位元組輸出流【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)： 建立檔案輸出流以指定的名稱寫入檔案。

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

寫出位元組資料

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

小貼士：

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

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

資料追加續寫

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

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

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

寫出換行

Windows系統裡，換行符號是\r\n 。把
以指定是否追加續寫了，程式碼使用演示：

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

package IO.位元組流.demo01;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/*輸出流*/
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        File file= new File("E:\\Data\\1\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        //FileOutputStream fos = new FileOutputStream(file,true); //true追加寫，預設false:清空後在寫
        fos.write(97);
        fos.write(98);
        fos.write(99);

        byte[] b = "學習Java IO流".getBytes();
        fos.write(b);


        byte[] c = "abcde".getBytes();
        fos.write(c,2,2);
        fos.write("\r\n".getBytes());
        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();
    }
}

位元組輸入流【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 。

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

讀取位元組資料

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

小貼士：

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

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

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

package IO.位元組流.demo01;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\Data\\1\\b.txt");
        FileInputStream fis = new FileInputStream(file);
        int b;
        while((b = fis.read())!=-1){
            System.out.println((char)b);    ;
        }
        fis.close();
    }
}



package IO.位元組流.demo01
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FISRead {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\Data\\1\\b.txt");
        FileInputStream fis = new FileInputStream(file);

        int len;
        byte[] c = new byte[2];
        while((len = fis.read(c))!=-1){
            //System.out.println(new String(c));
            System.out.println(new String(c,0,len));
        }
        fis.close();
    }
}

位元組流練習：圖片複製

複製原理圖解

案例實現

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

package IO.位元組流.demo01;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class PictureCopy {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\Data\\1\\test.png");
        File file2 = new File("E:\\Data\\1\\testcopy.png");
        FileInputStream fis = new FileInputStream(file);
        FileOutputStream fos = new FileOutputStream(file2);
        int b;
        while((b = fis.read())!=-1){
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

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

字元流

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

字元輸入流【Reader】

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

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

FileReader類

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

小貼士：

1. 字元編碼：位元組與字元的對應規則。Windows系統的中文編碼預設是GBK編碼表。
   idea中UTF-8
   
2. 位元組緩衝區：一個位元組陣列，用來臨時儲存位元組資料。
   

構造方法

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

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

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

讀取字元資料

1. 讀取字元：read方法，每次可以讀取一個字元的資料，提升為int型別，讀取到檔案末尾，返回-1，迴圈讀取，程式碼使用演示：> 小貼士：雖然讀取了一個字元，但是會自動提升為int型別。

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

package IO.字元流;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\Data\\1\\c.txt");
        FileReader fr = new FileReader(file);

        int b;
        while((b = fr.read())!= -1){
            System.out.print((char)b);
        }
        fr.close();
        fr = new FileReader(file);
        int len;
        char[] cbuf  = new char[1024];
        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。

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

基本寫出資料

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

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

關閉和重新整理

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

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

程式碼使用演示：

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

寫出其他資料

1.寫出字元陣列 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以寫出字元陣列中的資料，用法類似FileOutputStream，程式碼使用演示：
2.寫出字串：write(String str) 和 write(String str, int off, int len) ，每次可以寫出字串中的資料，更為方便，程式碼使用演示：
3.續寫和換行：操作類似於FileOutputStream。

小貼士：字元流，只能操作文字檔案，不能操作圖片，視訊等非文字檔案。
當我們單純讀或者寫文字檔案時 使用字元流 其他情況使用位元組流

package IO.字元流;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterTest {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\Data\\1\\d.txt");
        FileWriter fw = new FileWriter(file);

        /*
        寫入單個字元
         */
        fw.write(97);
        fw.write('b');
        fw.write('c');
        fw.write(30000);
        //fw.flush();   //重新整理緩衝區資料到檔案
        fw.close();  //不重新整理也不不關閉的話，資料只能儲存在緩衝區，並未寫入檔案

        /*
        寫入字元陣列
         */
        fw = new FileWriter(file,true);
        char[] wbuf = "Java程式設計師".toCharArray();
        fw.write(wbuf);
        fw.write('學');
        fw.write(wbuf,0,4);
        fw.close();
    }
}

屬性集

概述

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() ：所有鍵的名稱的集合。

package IO.屬性集;

import java.util.Properties;
import java.util.Set;

public class ProDemo {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("filename","a.txt");
        properties.setProperty("length","1024");
        properties.setProperty("location","E:\\Data\\1");
        System.out.println(properties);
        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)： 從位元組輸入流中讀取鍵值對。

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

name=張三
age=20
sex=男

載入程式碼演示：

package IO.屬性集;


import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class ProDemo02 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.load(new FileReader("ccc.txt"));

        Set<String> strings = properties.stringPropertyNames();
        for(String key:strings){
            System.out.println(key+" ---- "+properties.getProperty(key));
        }
    }
}
輸出結果：
sex ---- 男
name ---- 張三
age ---- 20

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

緩衝流

概述

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

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

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

位元組緩衝流

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

下面通過一個例項比較不適用緩衝流和使用緩衝流的效率

• 使用位元組流

package IO.緩衝流;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferredDemo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try(
                FileInputStream fis = new FileInputStream("E:\\Data\\1\\diamonds.csv");
                FileOutputStream fos = new FileOutputStream("E:\\Data\\1\\diamonds副本.csv")
        ){
          int b;
          while ((b = fis.read())!=-1){
              fos.write(b);
          }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("time:"+ (end-start)+" ms");
    }
}
time:12990 ms

• 使用位元組緩衝流

package IO.緩衝流;

import java.io.*;

public class BufferedDemo2 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        try(
                BufferedInputStream bis = new BufferedInputStream( new FileInputStream("E:\\Data\\1\\diamonds.csv"));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\Data\\1\\diamonds副本.csv"))
        ){
            int b;
            while ((b = bis.read())!=-1){
                bos.write(b);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("time:"+ (end-start)+" ms");
    }
}

time:189 ms

很明顯位元組緩衝流的速度比位元組流快了數倍。
**

字元緩衝流

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

下面通過一個例子看看字元緩衝流：請將文字資訊恢復順序。
案例分析

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

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

案例實現

package IO.緩衝流;

import java.io.*;
import java.util.HashMap;

public class ChuShiBiaoTest {
    public static void main(String[] args) throws IOException {
        HashMap<String,String> linemap = new HashMap<>();
        BufferedReader br = new BufferedReader(new FileReader("E:\\Data\\1\\出師表.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\Data\\1\\出師表-排序.txt"));

        String line = null;
        while((line = br.readLine())!=null){
            String[] spilt = line.split("\\.");
            linemap.put(spilt[0],spilt[1]);
        }
        br.close();
        for (int i = 1; i <=linemap.size(); i++) {	
            String key = String.valueOf(i);
            String value = linemap.get(key);
            bw.write(key+"."+value);	//排序寫入
        }
        bw.close();
    }
}

轉換流

字元編碼和字符集

字元編碼
計算機中儲存的資訊都是用二進位制數表示的，而我們在螢幕上看到的數字、英文、標點符號、漢字等字元是二進位制數轉換之後的結果。按照某種規則，將字元儲存到計算機中，稱為編碼 。反之，將儲存在計算機中的二進位制數按照某種規則解析顯示出來，稱為解碼 。比如說，按照A規則儲存，同樣按照A規則解析，那麼就能顯示正確的文字符號。反之，按照A規則儲存，再按照B規則解析，就會導致亂碼現象。
**編碼:    字元(能看懂的)--位元組(看不懂的)
解碼:    **位元組(看不懂的)-->字元(能看懂的)

• 字元編碼Character Encoding : 就是一套自然語言的字元與二進位制數之間的對應規則。
  編碼表: 生活中文字和計算機中二進位制的對應規則

字符集

• 字符集 Charset：也叫編碼表。是一個系統支援的所有字元的集合，包括各國家文字、標點符號、圖形符號、數字等。
  

計算機要準確的儲存和識別各種字符集符號，需要進行字元編碼，一套字符集必然至少有一套字元編碼。常見字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可見，當指定了編碼，它所對應的字符集自然就指定了，所以編碼才是我們最終要關心的。

• ASCII字符集 ：
  • ASCII（American Standard Code for Information Interchange，美國資訊交換標準程式碼）是基於拉丁字母的一套電腦編碼系統，用於顯示現代英語，主要包括控制字元（回車鍵、退格、換行鍵等）和可顯示字元（英文大小寫字元、阿拉伯數字和西文符號）。
    
  • 基本的ASCII字符集，使用7位（bits）表示一個字元，共128字元。ASCII的擴充套件字符集使用8位（bits）表示一個字元，共256字元，方便支援歐洲常用字元。
    
• ISO-8859-1字符集：
  • 拉丁碼錶，別名Latin-1，用於顯示歐洲使用的語言，包括荷蘭、丹麥、德語、義大利語、西班牙語等。
    
  • ISO-8859-1使用單位元組編碼，相容ASCII編碼。
    
• GBxxx字符集：
  • GB就是國標的意思，是為了顯示中文而設計的一套字符集。
    
  • GB2312：簡體中文碼錶。一個小於127的字元的意義與原來相同。但兩個大於127的字元連在一起時，就表示一個漢字，這樣大約可以組合了包含7000多個簡體漢字，此外數學符號、羅馬希臘的字母、日文的假名們都編進去了，連在ASCII裡本來就有的數字、標點、字母都統統重新編了兩個位元組長的編碼，這就是常說的"全形"字元，而原來在127號以下的那些就叫"半形"字元了。
    
  • GBK：最常用的中文碼錶。是在GB2312標準基礎上的擴充套件規範，使用了雙位元組編碼方案，共收錄了21003個漢字，完全相容GB2312標準，同時支援繁體漢字以及日韓漢字等。
    
  • GB18030：最新的中文碼錶。收錄漢字70244個，採用多位元組編碼，每個字可以由1個、2個或4個位元組組成。支援中國國內少數民族的文字，同時支援繁體漢字以及日韓漢字等。
    
• Unicode字符集 ：
  • Unicode編碼系統為表達任意語言的任意字元而設計，是業界的一種標準，也稱為統一碼、標準萬國碼。
    
  • 它最多使用4個位元組的數字來表達每個字母、符號，或者文字。有三種編碼方案，UTF-8、UTF-16和UTF-32。最為常用的UTF-8編碼。
    
  • UTF-8編碼，可以用來表示Unicode標準中任何字元，它是電子郵件、網頁及其他儲存或傳送文字的應用中，優先採用的編碼。網際網路工程工作小組（IETF）要求所有網際網路協議都必須支援UTF-8編碼。所以，我們開發Web應用，也要使用UTF-8編碼。它使用一至四個位元組為每個字元編碼，編碼規則：
    1. 128個US-ASCII字元，只需一個位元組編碼。
       
    2. 拉丁文等字元，需要二個位元組編碼。
       
    3. 大部分常用字（含中文），使用三個位元組編碼。
       
    4. 其他極少使用的Unicode輔助字元，使用四位元組編碼。
       

編碼引出的問題
在IDEA中，使用FileReader 讀取專案中的文字檔案。由於IDEA的設定，都是預設的UTF-8編碼，所以沒有任何問題。但是，當讀取Windows系統中建立的文字檔案時，由於Windows系統的預設是GBK編碼，就會出現亂碼。

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != -1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
}

輸出結果：
���

那麼如何讀取GBK編碼的檔案呢？

InputStreamReader類

轉換流java.io.InputStreamReader，是Reader的子類，是從位元組流到字元流的橋樑。它讀取位元組，並使用指定的字符集將其解碼為字元。它的字符集可以由名稱指定，也可以接受平臺的預設字符集。
構造方法

• InputStreamReader(InputStream in): 建立一個使用預設字符集的字元流。
  
• InputStreamReader(InputStream in, String charsetName): 建立一個指定字符集的字元流。
  

構造舉例，程式碼如下：
InputStreamReader`` ``isr`` ``=`` ``new`` ``InputStreamReader``(``new`` ``FileInputStream``(``"in.txt"``));
InputStreamReader`` ``isr2`` ``=`` ``new`` ``InputStreamReader``(``new`` ``FileInputStream``(``"in.txt"``) , ``"GBK"``);
指定編碼讀取

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
        // 定義檔案路徑,檔案為gbk編碼
        String FileName = "E:\\file_gbk.txt";
        // 建立流物件,預設UTF8編碼
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
        // 建立流物件,指定GBK編碼
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
        // 定義變數,儲存字元
        int read;
        // 使用預設編碼字元流讀取,亂碼
        while ((read = isr.read()) != -1) {
            System.out.print((char)read); // ��Һ�
        }
        isr.close();
      
        // 使用指定編碼字元流讀取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 大家好
        }
        isr2.close();
    }
}

OutputStreamWriter類

轉換流java.io.OutputStreamWriter ，是Writer的子類，是從字元流到位元組流的橋樑。使用指定的字符集將字元編碼為位元組。它的字符集可以由名稱指定，也可以接受平臺的預設字符集。
構造方法

• OutputStreamWriter(OutputStream in): 建立一個使用預設字符集的字元流。
  
• OutputStreamWriter(OutputStream in, String charsetName): 建立一個指定字符集的字元流。
  

構造舉例，程式碼如下：
OutputStreamWriter`` ``isr`` ``=`` ``new`` ``OutputStreamWriter``(``new`` ``FileOutputStream``(``"out.txt"``));
OutputStreamWriter`` ``isr2`` ``=`` ``new`` ``OutputStreamWriter``(``new`` ``FileOutputStream``(``"out.txt"``) , ``"GBK"``);
指定編碼寫出

public class OutputDemo {
    public static void main(String[] args) throws IOException {
        // 定義檔案路徑
        String FileName = "E:\\out.txt";
        // 建立流物件,預設UTF8編碼
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 寫出資料
        osw.write("你好"); // 儲存為6個位元組
        osw.close();
        
        // 定義檔案路徑
        String FileName2 = "E:\\out2.txt";
        // 建立流物件,指定GBK編碼
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 寫出資料
        osw2.write("你好");// 儲存為4個位元組
        osw2.close();
    }
}

轉換流理解圖解

練習：轉換檔案編碼

將GBK編碼的文字檔案，轉換為UTF-8編碼的文字檔案。

1. 指定GBK編碼的轉換流，讀取文字檔案。
   
2. 使用UTF-8編碼的轉換流，寫出文字檔案。

package IO.轉換流;

import java.io.*;

public class TransDemo {
    public static void main(String[] args) throws IOException{

        String srcFile = "file_gbk.txt";
        String destFile = "file_utf8.txt";

        InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));

        char[] cbuf = new char[1024];
        int len;
        while ((len = isr.read(cbuf))!=-1) {
            osw.write(cbuf,0,len);
        }

        osw.close();
        isr.close();
    }
}

序列化

Java 提供了一種物件序列化的機制。用一個位元組序列可以表示一個物件，該位元組序列包含該物件的資料、物件的型別和物件中儲存的屬性等資訊。位元組序列寫出到檔案之後，相當於檔案中持久儲存了一個物件的資訊。
反之，該位元組序列還可以從檔案中讀取回來，重構物件，對它進行反序列化。物件的資料、物件的型別和物件中儲存的資料資訊，都可以用來在記憶體中建立物件。看圖理解序列化：

ObjectOutputStream類

java.io.ObjectOutputStream 類，將Java物件的原始資料型別寫出到檔案,實現物件的持久儲存。
構造方法

• public ObjectOutputStream(OutputStream out)： 建立一個指定OutputStream的ObjectOutputStream。
  

構造舉例，程式碼如下：
FileOutputStream`` ``fileOut`` ``=`` ``new`` ``FileOutputStream``(``"employee.txt"``);
ObjectOutputStream`` ``out`` ``=`` ``new`` ``ObjectOutputStream``(``fileOut``);
序列化操作

1. 一個物件要想序列化，必須滿足兩個條件:
   

• 該類必須實現java.io.Serializable 介面，Serializable 是一個標記介面，不實現此介面的類將不會使任何狀態序列化或反序列化，會丟擲NotSerializableException 。
  
• 該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須註明是瞬態的，使用transient 關鍵字修飾。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬態修飾成員,不會被序列化
    public void addressCheck() {
        System.out.println("Address  check : " + name + " -- " + address);
    }
}

2.寫出物件方法

• public final void writeObject (Object obj) : 將指定的物件寫出。

public class SerializeDemo{
    public static void main(String [] args)   {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20; 
        try {
            // 建立序列化流物件
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 寫出物件
            out.writeObject(e);
            // 釋放資源
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年齡沒有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
    }
}
輸出結果：
Serialized data is saved

ObjectInputStream類

ObjectInputStream反序列化流，將之前使用ObjectOutputStream序列化的原始資料恢復為物件。
構造方法

• public ObjectInputStream(InputStream in)： 建立一個指定InputStream的ObjectInputStream。
  

反序列化操作1
如果能找到一個物件的class檔案，我們可以進行反序列化操作，呼叫ObjectInputStream讀取物件的方法：

• public final Object readObject () : 讀取一個物件。

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {       
             // 建立反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 讀取一個物件
             e = (Employee) in.readObject();
             // 釋放資源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕獲其他異常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
            // 捕獲類找不到異常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 無異常,直接列印輸出
        System.out.println("Name: " + e.name);  // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

對於JVM可以反序列化物件，它必須是能夠找到class檔案的類。如果找不到該類的class檔案，則丟擲一個 ClassNotFoundException 異常。
反序列化操作2
另外，當JVM反序列化物件時，能找到class檔案，但是class檔案在序列化物件之後發生了修改，那麼反序列化操作也會失敗，丟擲一個InvalidClassException異常。發生這個異常的原因如下：

• 該類的序列版本號與從流中讀取的類描述符的版本號不匹配
  
• 該類包含未知資料型別
  
• 該類沒有可訪問的無引數構造方法
  

Serializable 介面給需要序列化的類，提供了一個序列版本號。serialVersionUID 該版本號的目的在於驗證序列化的物件和對應類是否版本匹配。

public class Employee implements java.io.Serializable {
     // 加入序列版本號
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 新增新的屬性 ,重新編譯, 可以反序列化,該屬性賦為預設值.
     public int eid; 
     public void addressCheck() {
         System.out.println("Address  check : " + name + " -- " + address);
     }
}

練習：序列化集合

1. 將存有多個自定義物件的集合序列化操作，儲存到list.txt檔案中。
   
2. 反序列化list.txt ，並遍歷集合，列印物件資訊。
   

案例分析

1. 把若干學生物件 ，儲存到集合中。
   
2. 把集合序列化。
   
3. 反序列化讀取時，只需要讀取一次，轉換為集合型別。
   
4. 遍歷集合，可以列印所有的學生資訊
   

案例實現

public class SerTest {
    public static void main(String[] args) throws Exception {
        // 建立 學生物件
        Student student = new Student("老王", "laow");
        Student student2 = new Student("老張", "laoz");
        Student student3 = new Student("老李", "laol");
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
        // 序列化操作
        // serializ(arrayList);
        
        // 反序列化  
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
        // 讀取物件,強轉為ArrayList型別
        ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
        
        for (int i = 0; i < list.size(); i++ ){
            Student s = list.get(i);
            System.out.println(s.getName()+"--"+ s.getPwd());
        }
    }
    private static void serializ(ArrayList<Student> arrayList) throws Exception {
        // 建立 序列化流 
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        // 寫出物件
        oos.writeObject(arrayList);
        // 釋放資源
        oos.close();
    }
}

列印流

平時我們在控制檯列印輸出，是呼叫print方法和println方法完成的，這兩個方法都來自java.io.PrintStream類，該類能夠方便地列印各種資料型別的值，是一種便捷的輸出方式。

PrintStream類

構造方法

• public PrintStream(String fileName)： 使用指定的檔名建立一個新的列印流。
  

構造舉例，程式碼如下：
PrintStream ps = new PrintStream("ps.txt")；
改變列印流向
System.out就是PrintStream型別的，只不過它的流向是系統規定的，列印在控制檯上。不過，既然是流物件，我們就可以玩一個"小把戲"，改變它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
 	// 呼叫系統的列印流,控制檯直接輸出97
        System.out.println(97);
      
 	// 建立列印流,指定檔案的名稱
        PrintStream ps = new PrintStream("ps.txt");
       
       // 設定系統的列印流流向,輸出到ps.txt
        System.setOut(ps);
       // 呼叫系統的列印流,ps.txt中輸出97
        System.out.println(97);
    }
}

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