主要內容

異常處理
緩衝流
轉換流
序列化流
打印流
屬性集

第一章緩衝流

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

1.1 概述

緩衝流是對4個基本的FileXxx 流的增強，所以也是4個流，按照流操作數據的數據類型分類：

字節緩衝流：BufferedInputStream，BufferedOutputStream
字符緩衝流：BufferedReader，BufferedWriter

緩衝流的基本原理，是在創建流對象時，會創建一個內置的默認大小的緩衝區數組，通過緩衝區讀寫，減少系統IO次數，從而提高讀寫的效率。

1.2 字節緩衝流

構造方法

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

說明：我們發現上述緩衝流的參數依然需要對應的字節流對象。

這是因爲緩衝區流是爲了高效而設計的，緩衝區流本身僅僅是維護了一個數組。不具備讀和寫的功能。真正的讀寫還是要依賴普通的字節流。

構造舉例，代碼如下：

// 創建字節緩衝輸入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day09\\bis.txt"));
// 創建字節緩衝輸出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day09\\bos.txt"));

效率測試

查詢API，緩衝流讀寫方法與基本的流是一致的，我們通過複製大文件，測試它的效率。

基本流，代碼如下：

public class BufferedDemo {
    public static void main(String[] args) {
        // 記錄開始時間
      	long start = System.currentTimeMillis();
		// 創建流對象
        try (
        	FileInputStream fis = new FileInputStream("D:\\test\\制服誘惑2.mp4");
        	FileOutputStream fos = new FileOutputStream("F:\\制服誘惑2.mp4")
        ){
        	// 讀寫數據
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
		// 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("普通流複製時間:"+(end - start)+" 毫秒");
    }
}

普通流複製時間:288242 毫秒

2.緩衝流，代碼如下：

public class BufferedDemo {
    public static void main(String[] args){
        // 記錄開始時間
      	long start = System.currentTimeMillis();
		// 創建流對象
        try (
        	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test\\制服誘惑2.mp4"));
	     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\制服誘惑2.mp4"));
        ){
        // 讀寫數據
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
		// 記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("緩衝流複製時間:"+(end - start)+" 毫秒");
    }
}

緩衝流複製時間:2108 毫秒

如何更快呢？

使用數組的方式，代碼如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
      	// 記錄開始時間
        long start = System.currentTimeMillis();
		// 創建流對象
        try (
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test\\制服誘惑2.mp4"));
		 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\制服誘惑2.mp4"));
        ){
          	// 讀寫數據
            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)+" 毫秒");
    }
}
緩衝流使用數組複製時間:115 毫秒

1.3 字符緩衝流

構造方法

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

構造舉例，代碼如下：

// 創建字符緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("E:\\br.txt"));
// 創建字符緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\bw.txt"));

特有方法

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

BufferedReader：public String readLine(): 經常使用它讀取一行數據。readLine方法可以按照行讀取，讀取的結束標記’\r’’\n’，返回的結果是讀到這一行的所有文字。如果讀取到文件的末尾返回 null。
BufferedWriter：public void newLine(): 寫一行行分隔符。就是換行。

readLine方法演示，代碼如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
      	 // 創建流對象
        BufferedReader br = new BufferedReader(new FileReader("E:\\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("E:\\out.txt"));
      	// 寫出數據
        bw.write("黑馬");
      	// 寫出換行
        bw.newLine();
        bw.write("程序");
        bw.newLine();
        bw.write("員");
        bw.newLine();
		// 釋放資源
        bw.close();
    }
}
輸出效果:
黑馬
程序
員

1.4 練習:文本排序

請將文本信息恢復順序。

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

準備工作：

在當前項目下面新建一個文件，叫做in.txt。然後將上述內容複製到in.txt文件中。注意每個序號後面要是一行數據。每個序號之間的數據要換行。效果如下圖所示。

案例分析

逐行讀取文本信息。
解析文本信息到集合中。
遍歷集合，按順序，寫出文本信息。

案例實現

/*
分析：原來文本文件中的數據是亂序的，我們現在要求將文本文件in.txt中的無序的數據按照順序寫到一個文件out.txt中。
    1. 逐行讀取文本信息。
        數據源文件in.txt屬於文本文件，使用字符輸入流---一行一行---高效的字符輸入流BufferedReader 方法 readLine()
    2. 解析文本信息到集合中。
        每一行數據有個特點:  3.侍中、侍郎郭攸之、費禕
         數字+"."+文本數據
         讀取到這一行數據，將其進行切割  使用String類中 split("\\.")
         注意：這裏要書寫  \\. 不能直接書寫 . 因爲在這裏.具備特殊含義 表示任意的字符
         而我們這裏希望是真正的 點，所以需要使用\將點進行轉義，但是在java中\\表示一個真正的\
         總結：\\.表示我們生活中的一個 .

         3.侍中、侍郎郭攸之、費禕、董允等，....
         8.願陛下託臣以討賊興復之效。。。
         按照上述做法切割完成之後，數組長度是2
         索引     數據
         0       3
         1       侍中、侍郎郭攸之、費禕、董允等，....
         將截取的數據存放到Map集合中
         序號作爲key  文本數據作爲value
         HashMap<Integer,String> hm = new HashMap<Integer,String>();
         hm.put(3,"侍中、侍郎郭攸之、費禕、董允等，....");----->hm.put(Integer.parseInt(arr[0]),arr[1]);
    3. 遍歷集合，按順序，寫出文本信息。

        //遍歷
        for(int i=1;i<=hm.size();i++)
        {
            //i賦值給key
            Integer key=i;
            //根據key獲取值
            String value = hm.get(key);
            //寫文本信息 一行一行  BufferedWriter  換行 newLine()
            每一行信息包括： bw.write(key+"."+value);
        }
 */
public class BufferedTest {
    public static void main(String[] args) throws Exception {
        //1. 逐行讀取文本信息。
        //1.1 創建高效字符輸入流對象關聯數據源文件
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        //1.2 調用方法讀取數據
        //創建集合對象保存切割後的序號和文本數據 key ： 存儲序號 3   value ： 存儲文本數據
        HashMap<Integer, String> hm = new HashMap<>();
        String line = null;
        while ((line = br.readLine()) != null) {
            //1.3 截取讀取的數據
            String[] arr = line.split("\\.");
            //2. 解析文本信息到集合中。  3.侍中、侍郎郭攸之、費禕、董允等，....
            //由於key位置是Integer類型，而 數組中第一個數據是字符串，所以需要轉換
            int key = Integer.parseInt(arr[0]);
            //添加到集合中
            hm.put(key, arr[1]);//key:3 value:侍中、侍郎郭攸之、費禕、董允等，....
        }
       
        //關閉資源
        br.close();
        //創建字符高效輸出流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
        //3. 遍歷集合，按順序，寫出文本信息。
        for (int i = 1; i <= hm.size(); i++) {
            //獲取i就是key，i賦值給key
            Integer key = i;
            //根據key獲取value
            String value = hm.get(key);
            //將遍歷出來的key和value寫到out.txt中
            bw.write(key+"."+value);
            //換行
            bw.newLine();
        }
        //釋放資源
        bw.close();
    }
}

第二章轉換流

2.1 字符編碼和字符集

字符編碼

計算機中儲存的信息都是用二進制數表示的，而我們在屏幕上看到的數字、英文、標點符號、漢字等字符是二進制數轉換之後的結果。按照某種規則，將字符存儲到計算機中，稱爲編碼。反之，將存儲在計算機中的二進制數按照某種規則解析顯示出來，稱爲解碼。比如說，按照A規則存儲，同樣按照A規則解析，那麼就能顯示正確的文本f符號。反之，按照A規則存儲，再按照B規則解析，就會導致亂碼現象。

字符編碼Character Encoding : 就是一套我們人類語言的字符與二進制數之間的對應規則。

字符集

字符集 Charset：是一個系統支持的所有字符的集合，包括各國家文字、標點符號、數字等。

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

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

ASCII字符集 ：
- ASCII（American Standard Code for Information Interchange，美國信息交換標準代碼）是基於拉丁字母的一套電腦編碼系統，用於顯示現代英語，主要包括控制字符（回車鍵、退格、換行鍵等）和可顯示字符（英文大小寫字符、阿拉伯數字）。
- 基本的ASCII字符集，使用7位（bits）表示一個字符，共128字符。ASCII的擴展字符集使用8位（bits）表示一個字符，共256字符，方便支持歐洲常用字符。
ASCII碼錶1個字節表示一個字符。

生活中的字符	十進制	二進制
A	65	01000001
B	66	01000010

………………

補充：(瞭解)

在美式英語中使用的特殊控制字符。其中：

0～31及127(共33個)是控制字符或通信專用字符（其餘爲可顯示字符），如控制符：LF（換行）、CR（回車）、FF（換頁）、DEL（刪除）、BS（退格)、BEL（響鈴）等；通信專用字符：SOH（文頭）、EOT（文尾）、ACK（確認）等；ASCII值爲8、9、10 和13 分別轉換爲退格、製表、換行和回車字符。它們並沒有特定的圖形顯示，但會依不同的應用程序，而對文本顯示有不同的影響。

32表示空格。

ISO-8859-1字符集：
- 拉丁碼錶，別名Latin-1，用於顯示歐洲使用的語言，包括荷蘭、丹麥、德語、意大利語、西班牙語等。
- ISO-5559-1使用單字節編碼，兼容ASCII編碼。
- ISO-8859-1編碼表1個字節表示一個字符
- ISO：International Standards Organization，國際標準化組織。
GBxxx字符集：
- GB就是國標的意思，是爲了顯示中文而設計的一套字符集。
- GB2312：簡體中文碼錶。叫做信息交換用漢字編碼字符集。它識別六七千的文字，兼容ASCII編碼表。2個字節表示一個漢字字符。
- GBK：叫做漢字編碼字符集，也可以叫做國標。是GB2312的升級版，識別2萬多箇中文字符。2個字節表示一個漢字字符。目前主流的編碼表。
- GB18030：是GBK的升級版，包含了大部分的中文（簡體、繁體、甲骨文、象形文等等），還有少數民族的文字，識別更多。每個字可以由1個、2個或4個字節組成。
Unicode字符集 ：

因爲世界上各個國家都開發了屬於自己的編碼表，造成編碼表不統一，世界計算機協會就爲編碼統一，制定了一張國際通用的編碼表：unicode碼錶
- Unicode編碼系統爲表達任意語言的任意字符而設計，是業界的一種標準，也稱爲統一碼。標準萬國碼。
- 有三種編碼方案，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輔助字符，使用四字節編碼。

可以識別漢字的編碼表有哪些：

	GB2312、GBK、GB18030、unicode、UTF-8

  在開發中常用的碼錶：ISO-8859-1、GBK、UTF-8、ASCII。

文字--->(數字) ：編碼： 就是把能看懂內容，轉換成看不懂的內容。

A      65      01000001

(數字)--->文字  : 解碼： 就是把看不懂的內容，轉換成看懂的內容。

 01000001  65    A
 亂碼：編碼和解碼使用的編碼表不一致導致的。

2.2 編碼引出的問題

在IDEA中，使用FileReader 讀取項目中的文本文件。由於IDEA的設置，都是默認的UTF-8編碼，所以沒有任何問題。但是，當讀取Windows系統中創建的文本文件時，由於Windows系統的默認是GBK編碼，就會出現亂碼。

需求：使用字符輸入流讀取E:\1.txt文件中的數據，要求：1.txt使用GBK編碼方式保存。

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

那麼如何讀取GBK編碼的文件呢？

2.3 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:\\1.txt";
      	// 創建流對象,默認UTF8編碼
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
      	// 創建流對象,指定GBK編碼
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
		// 定義變量,保存字符
        int read=0;
      	// 使用默認編碼字符流讀取,亂碼
        while ((read = isr.read()) != -1) {
            System.out.print((char)read); // ��
        }
        isr.close();
      
      	// 使用指定編碼字符流讀取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 你好
        }
        isr2.close();
    }
}

2.4 OutputStreamWriter類

轉換流java.io.OutputStreamWriter ，是Writer的子類，是從字符流到字節流的橋樑。使用指定的字符集將字符編碼轉換爲字節。它的字符集可以由名稱指定，也可以接受平臺的默認字符集。

構造方法

OutputStreamWriter(OutputStream in): 創建一個使用默認字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName): 創建一個指定字符集的字符流。

構造舉例，代碼如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("day10\\out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("day10\\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("你好"); 
        osw.close();
      	
		// 定義文件路徑
		String FileName2 = "E:\\out2.txt";
     	// 創建流對象,指定GBK編碼
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 寫出數據
      	osw2.write("你好");
        osw2.close();
    }
}

轉換流理解圖解

轉換流是字節與字符間的橋樑！

字節存在硬盤上。字符存在內存中。

總結

轉換流有兩個作用：

1. 指定讀寫的碼錶

2.可以把字節流對象變成字符流對象

2.5.練習：把UTF-8文件轉成GBK

需求：把D:\out.txt以UTF-8編碼的文件轉換爲以GBK編碼的文件

/*
    需求：把D:\\out.txt以UTF-8編碼的文件轉換爲 以GBK編碼的文件
 */
public class Test01 {
    public static void main(String[] args) throws Exception {
        //把這個文件換成GBK編碼  內容不變
        //創建輸入流
        //默認按照UTF-8方式讀取
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\out.txt"));
        //創建輸出流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\123.txt"),"GBK");
        //循環讀寫
        int a;
        //每次讀取一個字符
        while((a=isr.read()) != -1){
            //寫出一個字符
            osw.write(a);
        }
        //關流
        osw.close();
        isr.close();
    }
}

第三章序列化

3.1 概述

Java 提供了一種對象序列化的機制。用一個字節序列可以表示一個對象，該字節序列包含該對象的數據、對象的類型和對象中存儲的數據等信息。字節序列寫出到文件之後，相當於文件中持久保存了一個對象的信息。

反之，該字節序列還可以從文件中讀取回來，重構對象，對它進行反序列化。對象的數據、對象的類型和對象中存儲的數據信息，都可以用來在內存中創建對象。看圖理解序列化：

3.2 ObjectOutputStream類

java.io.ObjectOutputStream 類，將Java對象的原始數據類型寫出到文件,實現對象的持久存儲。

構造方法

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

構造舉例，代碼如下：

FileOutputStream fileOut = new FileOutputStream("E:\\s.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

一個對象要想序列化，必須滿足兩個條件:

該類必須實現java.io.Serializable 接口，Serializable 是一個標記接口，不實現此接口的類將不會使任何狀態序列化或反序列化，會拋出NotSerializableException 。

說明：Serializable：它是一個標記性接口。這個接口中沒有任何的方法，這種接口稱爲標記型接口！它僅僅是一個標識。是一個標記接口爲了啓動一個序列化功能。只有具備了這個接口標識的類才能通過Java中的序列化和反序列化流操作這個對象。

注意：只要一個類實現了Serializable接口，那麼都會給每個實現類分配一個序列版本號作爲唯一標識。
該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須註明是瞬態的，使用transient 關鍵字修飾。

//爲了保證學生對象可以被序列化，我們讓Student類來實現Serializable接口
public class Student implements Serializable {
	//屬性
	private String name;
	private transient int age; // transient瞬態修飾成員,不會被序列化
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

2.寫出對象方法

public final void writeObject (Object obj) : 將指定的對象寫出。

public class SerializeDemo{
   	public static void main(String [] args)  throws IOException {
        //創建學生對象
		Student s = new Student("黑旋風",18);
		//把創建出來的學生對象持久化保存在硬盤中
		//創建序列化對象  創建輸出流對象並關聯目標文件
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\s.txt"));
		//使用序列化對象中的方法持久化學生對象
		oos.writeObject(s);// 姓名被序列化，年齡沒有被序列化。
		//關閉資源
		oos.close();
   	}
}

3.3 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)  throws IOException, ClassNotFoundException {
        //創建反序列化對象，指定一個字節輸入流用來讀取持久文件
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\s.txt"));
		//使用反序列化對象ois調用函數進行讀取數據
		Student s = (Student) ois.readObject();
		System.out.println(s.getName()+"==="+s.getAge());
		//關閉資源
		ois.close();
    }
}
輸出結果：
  黑旋風===0

反序列化操作2

當在反序列化對象之前，我們對Student類做了一些簡單的修改，無關緊要的修改。例如給Student類添加一個屬性字段或者函數都可以，再次反序列化，就出問題了，報如下圖所示的異常:

分析異常：

通過以上發生的異常我們發現是由於readObject()函數發生的異常，所以我們接下來會查看readObject()函數。

接下來查看InvalidClassException 異常類：

問題一：什麼是該類的序列版本號呢？

類要進行序列化操作時，需要實現Serializable接口。(Serializable接口也稱爲標記接口)，實現了標記接口的類，該類會存在一個標記值。這個標記值就是該類的序列版本號。這個版本號和該類相關聯。

說明：也就是說只要一個類實現Serializable接口，那麼在編譯源文件時，生成的class文件中就會生成一個和該類相關聯的序列版本號。

問題二：這個版本號有什麼作用呢？

在序列化時，這個版本號會隨着對象一起被序列化到本地文件中。在反序列化的時候，使用流從硬盤上會讀取之前序列化的文件，那麼jvm會拿着使用流讀取到的序列化的版本號和本地硬盤上即class文件中的序列化版本號進行匹配，如果不匹配就會拋異常。Java.io.InvalidClassException。

所以可以理解這個序列化版本號serialVersionUID是用來驗證的，防止反序列化的對象和本地的類不匹配。

問題三：這個序列化版本號是如何生成的呢？

由於實現類已經實現了Serializable接口，那麼只要重新編譯源文件的時候，編譯器就會根據類的各個方面(如類的成員變量、成員函數、修飾符、函數返回值類型等)計算成爲該類的默認 serialVersionUID 值（版本號）。

serialVersionUID 稱爲序列版本編號(標記值)。

上述代碼如果在反序列化之前修改Student類時，會在報的異常中出現如下圖所示的提示信息：

cn.itcast.sh.otherstream.demo.Student; 
local class incompatible: stream classdesc serialVersionUID = -7620680200402190796, 
local class serialVersionUID = 6830451359866645744

stream classdesc serialVersionUID = -7620680200402190796, 表示從流中讀取的版本號(反序列化時從硬盤文件中讀取的)

local class serialVersionUID = 6830451359866645744 ，表示Student類的序列版本號(表示Student類實現Serializable接口時，編譯後在生成的class文件中的序列化版本號)

上述兩個版本號不一致，所以報異常。

通過以上分析，可以得到一個結論：

如果可以保證反序列化對象和序列化對象的標記值相同，就可以避免異常的發生。

那麼我們如何做才能保證反序列化對象和序列化對象的標記值相同呢？

我們修改Student類是無關緊要的。在我們修改Student類的時候，我們不希望它拋異常。我們可以給類定義一個默認的版本號，即給Student類添加標記值也就是版本號serialVersionUID。這樣一來，添加的標記值即版本號會隨着對象的序列化持久保存。無論是序列化，還是反序列化，都不會再根據類的各個方面計算版本號了。序列化和反序列化的版本號會永遠一致，所以不會拋出異常，這樣就可以避免InvalidClassException異常的發生了。

但是，這樣一來，類的安全問題，只能自己來維護。因爲已經將類的對象序列化之後，由於類中已經顯示定義了版本號，那麼反序列化的時候即使修改了Student類，也不會報異常了。

在idea中給自定義類Student添加版本號方法如下所示：

1）File----->Settings

2）Editor–>inspections→serialization issues→選擇圖中的選項。勾上serializable class without ‘serialVersionUID’

3）點擊確定，將光標放到實體類上，按alt+回車就可以出現生成序列版本ID了

總結，記住：

1、當一個對象需要被序列化或反序列化的時候對象所屬的類需要實現Serializable接口。

2、被序列化的類中需要添加一個serialVersionUID。

3.4 練習：序列化集合

將存有多個自定義對象的集合序列化操作，保存到list.txt文件中。
反序列化list.txt ，並遍歷集合，打印對象信息。

案例分析

把若干學習對象，保存到集合中。
把集合序列化。
反序列化讀取時，只需要讀取一次，轉換爲集合類型。
遍歷集合，可以打印所有的學生信息

案例實現

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

第四章打印流(瞭解)

4.1 概述

平時我們在控制檯打印輸出，是調用print方法和println方法完成的，這兩個方法都來自於java.io.PrintStream類，該類能夠方便地打印各種數據類型的值，是一種便捷的輸出方式。

4.2 PrintStream類

構造方法

public PrintStream(String fileName)：使用指定的文件名創建一個新的打印流。

構造舉例，代碼如下：

PrintStream ps = new PrintStream("day10\\ps.txt")；

改變打印流向

System.out就是PrintStream類型的，只不過它的流向是系統規定的，打印在控制檯上。

public class Test01 {
    public static void main(String[] args) throws Exception {
        // 調用系統的打印流,控制檯直接輸出97
        System.out.println(97);

        // 創建打印流,指定文件的名稱
        PrintStream ps = new PrintStream("ps.txt");
        //直接使用對象調用方法輸出到指定文件中
        ps.println(100);

        //設置系統的打印流流向,輸出到ps.txt
        System.setOut(ps);

        System.out.println("你愛我");

        //打印流是自動刷新
        System.out.println(1);
        System.out.println(true);
        System.out.println("哈哈哈");

        ps.close();
    }
}

說明：System類中的static void setOut(PrintStream out) 方法表示重新分配“標準”輸出流。改變流的輸出方向。

第五章裝飾設計模式

在我們今天所學的緩衝流中涉及到java的一種設計模式，叫做裝飾模式，我們來認識並學習一下這個設計模式。

1.概述

裝飾模式指的是在不改變原類, 不使用繼承的基礎上，動態地擴展一個對象的功能,功能就是方法。

2.裝飾設計模式寫法

裝飾類和被裝飾類必須實現相同的接口 (必須有接口)
在裝飾類中必須傳入被裝飾類的引用(對象)
在裝飾類中對需要擴展的方法進行擴展
在裝飾類中對不需要擴展的方法調用被裝飾類中的同名方法

3.代碼演示

//明星接口 共同父接口
public interface Star {
    //唱歌
    public abstract void sing();
    //演戲
    public abstract void play();
}

//劉德華 被裝飾類
public class LiuDeHua implements Star {
    @Override
    public void sing() {
        System.out.println("劉德華唱冰雨");
    }

    @Override
    public void play() {
        System.out.println("劉德華演無間道");
    }
}

//劉德華增強類 裝飾類
public class BufferedLiuDeHua implements Star {

    //LiuDeHua類(被裝飾類)的對象作爲成員變量
    private LiuDeHua ldh;

    //構造方法
    public BufferedLiuDeHua(LiuDeHua ldh) {
        this.ldh = ldh;
    }

    @Override
    public void sing() {
        System.out.println("劉德華唱rap 淡黃的長裙 蓬鬆的頭髮");
    }

    @Override
    public void play() {
        //調用原來的方法
        ldh.play();
    }
}

public class Demo測試類 {
    public static void main(String[] args) {
        //測試劉德華這個類
        LiuDeHua ldh = new LiuDeHua();
        ldh.sing();
        ldh.play();

        //-------------------------------

        //測試劉德華增強類
        BufferedLiuDeHua bl = new BufferedLiuDeHua(ldh);
        bl.sing();
        bl.play();

    }
}

說明：

第六章 commons-io包

1.概述

commons-io是apache開源基金組織提供的一組有關IO操作的類庫，可以挺提高IO功能開發的效率。

這些內容不在JDK裏面，在使用的時候單獨導入。

2.使用方式

下載commons-io相關jar包；http://commons.apache.org/proper/commons-io/

你無需下載，直接到今日下發的資料中找到使用即可。

把commons-io-2.6.jar包複製到指定的項目的lib目錄中

說明：以後我們只要使用不是jdk的內容即第三方(oracle屬於第一方，我們屬於第二方，其他的都是第三方)的技術都需要導包。

導包步驟：

1）在當前項目根目錄下新建一個lib(是library庫的縮寫)文件夾

2）將第三方jar包放到lib文件夾下

將commons-io-2.6.jar加入到classpath

選中jar包右鍵加入到classpath下。選擇add as library

注意：必須按照上面去做，否則無法使用。

3.方法

IOUtils類中

public static int copy(InputStream in, OutputStream out) 文件複製(適合文件大小爲2GB以下)
public static long copyLarge(InputStream in, OutputStream out) 文件複製(適合文件大小爲2GB以上)

public class Test01 {
    public static void main(String[] args) throws Exception {
        //在IOUtils類下面
        // public static int copy(InputStream in, OutputStream out)      文件複製(適合文件大小爲2GB以下)
        // public static long copyLarge(InputStream in, OutputStream out) 文件複製(適合文件大小爲2GB以上)

        //輸入流
        FileInputStream fis = new FileInputStream("3.jpg");
        //輸出流
        FileOutputStream fos = new FileOutputStream("4.jpg");

        //複製
        IOUtils.copy(fis,fos);

        //關流
        fos.close();
        fis.close();
    }
}

FileUtils類中

public static void copyFileToDirectory(File srcFile, File destFile) //複製文件到另外一個目錄下。

public static void copyDirectoryToDirectory(File srcDir,File destDir);文件夾複製，將srcDir複製到destDir

需求1：將D:\1.mp3複製到F盤

需求2：D:\test文件夾複製到F盤下

public class Test01 {
    public static void main(String[] args) throws Exception {
//        public static void copyFileToDirectory(File srcFile, File destFile) //複製文件到另外一個目錄下。
//        public static void copyDirectoryToDirectory(File srcDir,File destDir);文件夾複製，將srcDir複製到destDir
        //需求：將D:\1.mp3複製到F盤
        //文件
//        File f1 = new File("D:\\1.mp3");
//        //文件夾
//        File f2 = new File("F:\\");
//
//        //調用方法
//        FileUtils.copyFileToDirectory(f1,f2);


        //copyDirectoryToDirectory() :把文件夾複製到一個文件夾下
        //文件夾
        File f3 = new File("D:\\test");
        ////文件夾
        File f4 = new File("F:\\");
        //調用方法
        FileUtils.copyDirectoryToDirectory(f3,f4);
    }
}

day22【功能流之緩衝流、轉換流、序列化流】

主要內容

第一章 緩衝流

1.1 概述

1.2 字節緩衝流

構造方法

效率測試

1.3 字符緩衝流

構造方法

特有方法

1.4 練習:文本排序

案例分析

案例實現

第二章 轉換流

2.1 字符編碼和字符集

字符編碼

字符集

2.2 編碼引出的問題

2.3 InputStreamReader類

構造方法

指定編碼讀取

2.4 OutputStreamWriter類

構造方法

指定編碼寫出

轉換流理解圖解

2.5.練習：把UTF-8文件轉成GBK

第三章 序列化

3.1 概述

3.2 ObjectOutputStream類

構造方法

序列化操作

3.3 ObjectInputStream類

構造方法

反序列化操作1

反序列化操作2

3.4 練習：序列化集合

案例分析

案例實現

第四章 打印流(瞭解)

4.1 概述

4.2 PrintStream類

構造方法

改變打印流向

第五章 裝飾設計模式

1.概述

2.裝飾設計模式寫法

3.代碼演示

第六章 commons-io包

1.概述

2.使用方式

3.方法

第一章緩衝流

第二章轉換流

第三章序列化

第四章打印流(瞭解)

第五章裝飾設計模式