IO流

1.流

概念：流就是一系列的資料

1.1 什麼是流

① 當不同的介質之間有資料互動的時候，JAVA就使用流來實現

② 資料來源可以是檔案，還可以是資料庫，網路甚至是其他的程式

③ 比如讀取檔案的資料到程式中，站在程式的角度來看，就叫做輸入流

輸入流： InputStream

輸出流：OutputStream

1.2 檔案輸入流

① 建立了一個檔案輸入流，這個流可以用來把資料從硬碟的檔案，讀取到JVM(記憶體)。

程式碼：

1File f = new File("d:/test.txt");
2// 建立基於檔案的輸入流
3FileInputStream fis = new FileInputStream(f);
 

2. 位元組流

概念：用於以位元組的形式讀取和寫入資料『InputStream、OutputStream』

2.1 ASCII碼 概念

① 所有的資料存放在計算機中都是以數字的形式存放的。 所以字母就需要轉換為數字才能夠存放。

② 比如：A就對應的數字65，a對應的數字97. 不同的字母和符號對應不同的數字，就是一張碼錶。

③ ASCII是這樣的一種碼錶。 只包含簡單的英文字母、符號、數字等等。

2.2 以位元組流的形式讀取檔案內容

① InputStream是位元組輸入流，同時也是抽象類，只提供方法宣告，不提供方法的具體實現。

② FileInputStream 是InputStream子類，以FileInputStream 為例進行檔案讀取

程式碼：

 1//準備檔案test.txt 其中的內容是AB，對應的ASCII分別是65 66
 2File f =new File("d:/test.txt");
 3FileInputStream fis =new FileInputStream(f);
 4//建立位元組陣列，其長度就是檔案的長度
 5byte[] all =new byte[(int) f.length()];
 6//以位元組流的形式讀取檔案所有內容
 7fis.read(all);
 8for (byte b : all) {
 9//打印出來是65 66
10System.out.println(b);
11}
12//每次使用完流，都應該進行關閉
13fis.close();
 

2.3 以位元組流的形式讀取檔案內容

① OutputStream是位元組輸出流，同時也是抽象類，只提供方法宣告，不提供方法的具體實現。

② FileOutputStream 是OutputStream子類，以FileOutputStream 為例向檔案寫出資料。

注: 如果檔案d:/test2.txt不存在，寫出操作會自動建立該檔案。但是如果是檔案 d:/xyz/test2.txt，而目錄xyz又不存在，會丟擲異常

程式碼：

 1// 準備檔案test2.txt其中的內容是空的
 2File f = new File("d:/test2.txt");
 3// 準備長度是2的位元組陣列，用88,89初始化，其對應的字元分別是X,Y
 4byte data[] = { 88, 89 };
 5// 建立基於檔案的輸出流
 6FileOutputStream fos = new FileOutputStream(f);
 7// 把資料寫入到輸出流
 8fos.write(data);
 9// 關閉輸出流
10fos.close();
11} catch (IOException e) {
12// TODO Auto-generated catch block
13e.printStackTrace();
14}

3. 字元流

概念：Reader字元輸入流、Writer字元輸出流、專門用於字元的形式讀取和寫入資料。

3.1使用字元流讀取檔案

程式碼：

 1// 準備檔案test.txt其中的內容是AB
 2File f = new File("d:/test.txt");
 3// 建立基於檔案的Reader
 4try (FileReader fr = new FileReader(f)) {
 5// 建立字元陣列，其長度就是檔案的長度
 6char[] all = new char[(int) f.length()];
 7// 以字元流的形式讀取檔案所有內容
 8fr.read(all);
 9for (char b : all) {
10// 打印出來是A B
11System.out.println(b);
12}
13} catch (IOException e) {
14// TODO Auto-generated catch block
15e.printStackTrace();
16}

3.2 使用字元流把字串寫入到檔案

程式碼：

 1// 準備檔案test.txt
 2File f = new File("d:/test.txt");
 3// 建立基於檔案的Writer
 4try (FileWriter fr = new FileWriter(f)) {
 5// 以字元流的形式把資料寫入到檔案中
 6String data="abcdefg";
 7char[] cs = data.toCharArray();
 8fr.write(cs);
 9} catch (IOException e) {
10// TODO Auto-generated catch block
11e.printStackTrace();
12}

4.快取流

介紹：以介質是硬碟為例，位元組流和字元流的弊端：

① 在每一次讀寫的時候，都會訪問硬碟。 如果讀寫的頻率比較高的時候，其效能表現不佳。

② 為了解決以上弊端，採用快取流。

③ 快取流在讀取的時候，會一次性讀較多的資料到快取中，以後每一次的讀取，都是在快取中訪問，直到快取中的資料讀取完畢，再到硬碟中讀取。

④ 就好比吃飯，不用快取就是每吃一口都到鍋裡去鏟。用快取就是先把飯盛到碗裡，碗裡的吃完了，再到鍋裡去鏟

⑤ 快取流在寫入資料的時候，會先把資料寫入到快取區，直到快取區達到一定的量，才把這些資料，一起寫入到硬碟中去。按照這種操作模式，就不會像位元組流，字元流那樣每寫一個位元組都訪問硬碟，從而減少了IO操作

4.1 使用快取流讀取資料

程式碼：

 1public static void main(String[] args) {
 2// 準備檔案test.txt其中的內容是
 3// sdasd
 4//asdasdasd
 5// sadsfadc
 6File f = new File("d:/test.txt");
 7// 建立檔案字元流
 8// 快取流必須建立在一個存在的流的基礎上
 9try (
10FileReader fr = new FileReader(f);
11BufferedReader br = new BufferedReader(fr);
12)
13{
14while (true) {
15// 一次讀一行
16String line = br.readLine();
17if (null == line)
18break;
19System.out.println(line);
20}
21} catch (IOException e) {
22// TODO Auto-generated catch block
23e.printStackTrace();
24}

4.2 使用快取流寫出資料

概念：PrintWriter 快取字元輸出流， 可以一次寫出一行資料

程式碼：

 1// 向檔案test2.txt中寫入三行語句
 2File f = new File("d:/test2.txt");
 3try (
 4// 建立檔案字元流
 5FileWriter fw = new FileWriter(f);
 6// 快取流必須建立在一個存在的流的基礎上
 7PrintWriter pw = new PrintWriter(fw);
 8) {
 9pw.println("garen kill teemo");
10pw.println("teemo revive after 1 minutes");
11pw.println("teemo try to garen, but killed again");
12} catch (IOException e) {
13// TODO Auto-generated catch block
14e.printStackTrace();
15}

4.3 flush

概念：有的時候，需要立即把資料寫入到硬碟，而不是等快取滿了才寫出去。 這時候就需要用到flush

程式碼：

 1//向檔案test2.txt中寫入三行語句
 2File f =new File("d:/test2.txt");
 3//建立檔案字元流
 4//快取流必須建立在一個存在的流的基礎上
 5try(FileWriter fr = new FileWriter(f);PrintWriter pw = newPrintWriter(fr);) {
 6pw.println("garen kill teemo");
 7//強制把快取中的資料寫入硬碟，無論快取是否已滿
 8pw.flush();
 9pw.println("teemo revive after 1 minutes");
10pw.flush();
11pw.println("teemo try to garen, but killed again");
12pw.flush();
13} catch (IOException e) {
14// TODO Auto-generated catch block
15e.printStackTrace();
16}
17}

5. 資料流

介紹：

① 直接進行字串的讀寫

② 使用資料流的writeUTF()和readUTF() 可以進行資料的格式化順序讀寫

③ 如本例，通過DataOutputStream 向檔案順序寫出 布林值，整數和字串。 然後再通過DataInputStream 順序讀入這些資料。

④ 注： 要用DataInputStream 讀取一個檔案，這個檔案必須是由DataOutputStream 寫出的，否則會出現EOFException，因為DataOutputStream 在寫出的時候會做一些特殊標記，只有DataInputStream 才能成功的讀取。

程式碼：

 1public static void main(String[] args) {
 2write();
 3read();
 4}
 5private static void read() {
 6File f =new File("d:/test.txt");
 7try (
 8FileInputStream fis  = new FileInputStream(f);
 9DataInputStream dis =new DataInputStream(fis);
10){
11boolean b= dis.readBoolean();
12int i = dis.readInt();
13String str = dis.readUTF();
14System.out.println("讀取到布林值:"+b);
15System.out.println("讀取到整數:"+i);
16System.out.println("讀取到字串:"+str);
17} catch (IOException e) {
18e.printStackTrace();
19}
20}
21private static void write() {
22File f =new File("d:/test.txt");
23try (
24FileOutputStream fos  = newFileOutputStream(f);
25DataOutputStream dos =newDataOutputStream(fos);
26){
27dos.writeBoolean(false);
28dos.writeInt(200);
29dos.writeUTF("123 wew d wd s ");
30} catch (IOException e) {
31e.printStackTrace();
32}
33}

6. 物件流

6.1 介紹

① 物件流指的是可以直接把一個物件以流的形式傳輸給其他的介質，比如硬碟

② 一個物件以流的形式進行傳輸，叫做序列化。 該物件所對應的類，必須是實現Serializable介面

6.2序列化一個物件

①建立一個H物件，設定其名稱為g。

②把該物件序列化到一個檔案g.txt。

然後再通過序列化把該檔案轉換為一個H物件。

注：把一個物件序列化有一個前提是：這個物件的類，必須實現了Serializable介面。

程式碼：

 1public class Hero implements Serializable {
 2//表示這個類當前的版本，如果有了變化，比如新設計了屬性，就應該修改這個版本號
 3private static final long serialVersionUID = 1L;
 4public String name;
 5public float hp;
 6}
 7public class TestStream {
 8public static void main(String[] args) {
 9//建立一個Hero garen
10//要把Hero物件直接儲存在檔案上，務必讓Hero類實現Serializable介面
11Hero h = new Hero();
12h.name = "garen";
13h.hp = 616;
14//準備一個檔案用於儲存該物件
15File f =new File("d:/garen.lol");
16try(
17//建立物件輸出流
18FileOutputStream fos = new FileOutputStream(f);
19ObjectOutputStream oos =new ObjectOutputStream(fos);
20//建立物件輸入流
21FileInputStream fis = new FileInputStream(f);
22ObjectInputStream ois =new ObjectInputStream(fis);
23) {
24oos.writeObject(h);
25Hero h2 = (Hero) ois.readObject();
26System.out.println(h2.name);
27System.out.println(h2.hp);
28} catch (IOException e) {
29// TODO Auto-generated catch block
30e.printStackTrace();
31} catch (ClassNotFoundException e) {
32// TODO Auto-generated catch block
33e.printStackTrace();
34}
35}
36}

2. 關閉流的方式

概念：所有的流，無論是輸入流還是輸出流，使用完畢之後，都應該關閉。 如果不關閉，會產生對資源佔用的浪費。 當量比較大的時候，會影響到業務的正常開展。

2.1 在try中關閉

弊端：如果檔案不存在，或者讀取的時候出現問題而丟擲異常，那麼就不會執行這一行關閉流的程式碼，存在巨大的資源佔用隱患。

程式碼：

 1try {
 2File f = new File("d:/test.txt");
 3FileInputStream fis = new FileInputStream(f);
 4byte[] all = new byte[(int) f.length()];
 5fis.read(all);
 6for (byte b : all) {
 7System.out.println(b);
 8}
 9// 在try 裡關閉流
10fis.close();
11} catch (IOException e) {
12e.printStackTrace();
13}

2.2  在finally中關閉「標準的關閉流的方式」

介紹：

①  首先把流的引用宣告在 try 的外面，如果宣告在 try 裡面，其作用域無法抵達finally .

②  在 finally 關閉之前，要先判斷該引用是否為空

③ 關閉的時候，需要再一次進行 try catch 處理

程式碼：

 1File f = new File("d:/test.txt");
 2FileInputStream fis = null;
 3try {
 4fis = new FileInputStream(f);
 5byte[] all = new byte[(int) f.length()];
 6fis.read(all);
 7for (byte b : all) {
 8System.out.println(b);
 9}
10} catch (IOException e) {
11e.printStackTrace();
12} finally {
13// 在finally 裡關閉流
14if (null != fis)
15try {
16fis.close();
17} catch (IOException e) {
18// TODO Auto-generated catch block
19e.printStackTrace();
20}
21}

2.3 使用 try() 的方式「把流定義在 try() 裡,try 、catch 或者 finally 結束的時候，會自動關閉」

程式碼：

 1File f = new File("d:/test.txt");
 2//把流定義在try()裡,try,catch或者finally結束的時候，會自動關閉
 3try (FileInputStream fis = new FileInputStream(f)) {
 4byte[] all = new byte[(int) f.length()];
 5fis.read(all);
 6for (byte b : all) {
 7System.out.println(b);
 8}
 9} catch (IOException e) {
10e.printStackTrace();
11}