Java基礎----【緩衝流、轉換流、序列化流】
緩衝流、轉換流、序列化流
主要內容
- Properties 屬性集
- 轉換流
- 緩衝流
- 序列化流
- 列印流
第一章 屬性集
1.1 概述
java.util.Properties
繼承於Hashtable
,來表示一個持久的屬性集。它使用鍵值結構儲存資料,每個鍵及其對應值都是一個字串。該類也被許多Java類使用,比如獲取系統屬性時,System.getProperties
方法就是返回一個Properties
物件。
1.2 Properties類
構造方法
public Properties()
:建立一個空的屬性列表。
基本的儲存方法
public Object setProperty(String key, String value)
public String getProperty(String key)
:使用此屬性列表中指定的鍵搜尋屬性值。public Set<String> stringPropertyNames()
:所有鍵的名稱的集合。
import java.util.Properties;
import java.util.Set;
public class PropertiesTest1 {
public static void main(String[] args) {
// 1. 建立屬性集物件
Properties prop = new Properties();
// 2. 新增鍵值對元素
prop.setProperty("filename", "a.txt");
prop.setProperty("length", "1024");
prop.setProperty("location", "D:/a.txt");
// 3. 列印屬性集物件
System.out.println("prop = " + prop);
// 4. 通過鍵,獲取屬性值
String filename = prop. getProperty("filename");
String length = prop.getProperty("length");
String location = prop.getProperty("location");
System.out.println("filename = " + filename);
System.out.println("length = " + length);
System.out.println("location = " + location);
// 5. 遍歷屬性集,獲取所有鍵的集合
Set<String> keys = prop.stringPropertyNames();
System.out.println("--------------");
// 6. 列印鍵值對
for (String key : keys) {
String value = prop.getProperty(key);
System.out.println(key + " = " + value);
}
}
}
輸出結果:
prop = {filename=a.txt, length=1024, location=D:/a.txt}
filename = a.txt
length = 1024
location = D:/a.txt
--------------
filename = a.txt
length = 1024
location = D:/a.txt
與流相關的方法
public void load(InputStream inStream)
: 從位元組輸入流中讀取鍵值對。
引數中使用了位元組輸入流,通過流物件,可以關聯到某檔案上,這樣就能夠載入文字中的資料了。文字資料格式:
filename=a.txt
length=209385038
location=D:\\a.txt
載入程式碼演示:
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropertiesTest2 {
public static void main(String[] args) throws IOException {
// 1. 建立一個屬性集物件
Properties prop = new Properties();
// 2. 載入資料到 prop 物件中
prop.load(new FileInputStream("a.txt"));
// 3. 獲取所有的 key, 然後實現遍歷
Set<String> keys = prop.stringPropertyNames();
for (String key : keys) {
String value = prop.getProperty(key);
System.out.println(key + " = " + value);
}
}
}
輸出結果:
filename = a.txt
length = 209385038
location = D:\a.txt
小貼士:文字中的資料,必須是鍵值對形式,可以使用空格、等號、冒號等符號分隔。
第二章 轉換流
2.1 字元編碼和字符集
字元編碼
計算機中儲存的資訊都是用二進位制數表示的,而我們在螢幕上看到的數字、英文、標點符號、漢字等字元是二進位制數轉換之後的結果。按照某種規則,將字元儲存到計算機中,稱為編碼 。反之,將儲存在計算機中的二進位制數按照某種規則解析顯示出來,稱為解碼 。比如說,按照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編碼。它使用一至四個位元組為每個字元編碼,編碼規則:
- 128個US-ASCII字元,只需一個位元組編碼。
- 拉丁文等字元,需要二個位元組編碼。
- 大部分常用字(含中文),使用三個位元組編碼。
- 其他極少使用的Unicode輔助字元,使用四位元組編碼。
2.2 編碼引出的問題
在IDEA中,使用FileReader
讀取專案中的文字檔案。由於IDEA的設定,都是預設的UTF-8
編碼,所以沒有任何問題。但是,當讀取Windows系統中建立的文字檔案時,由於Windows系統的預設是GBK編碼,就會出現亂碼。
import java.io.FileReader;
import java.io.IOException;
public class Test1 {
public static void main(String[] args) throws IOException {
// FileReader reader = new FileReader("a.txt");
FileReader reader = new FileReader("D:/a.txt");
int read = -1;
while ((read = reader.read()) != -1) {
System.out.println((char) read);
}
reader.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");
指定編碼讀取
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test3 {
public static void main(String[] args) throws IOException {
// 1. 建立一個字元轉換流物件 (預設為專案編碼 UTF-8)
InputStreamReader reader1 = new InputStreamReader(new FileInputStream("D:/a.txt"));
// 2. 建立一個字元轉換流物件 (指定編碼為 GBK)
InputStreamReader reader2 = new InputStreamReader(new FileInputStream("D:/a.txt"), "GBK");
// 讀取資料
int read = -1;
while ((read = reader1.read()) != -1) {
System.out.print((char)read);
}
System.out.println();
System.out.println("-------------");
read = -1;
while ((read = reader2.read()) != -1) {
System.out.print((char) read);
}
// 關閉資源
reader2.close();
reader1.close();
}
}
輸出結果 :
�Ұ��Ϻ�������.
-------------
我愛上海明珠塔.
2.4 OutputStreamWriter類
轉換流java.io.OutputStreamWriter
,是Writer的子類,是從字元流到位元組流的橋樑。使用指定的字符集將字元編碼為位元組。它的字符集可以由名稱指定,也可以接受平臺的預設字符集。
構造方法
OutputStreamWriter(OutputStream in)
: 建立一個使用預設字符集的字元流。OutputStreamWriter(OutputStream in, String charsetName)
: 建立一個指定字符集的字元流。
構造舉例,程式碼如下:
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
指定編碼寫出
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Test4 {
public static void main(String[] args) throws IOException {
// 1. 建立一個字元轉換流物件 (預設編碼: UTF-8)
OutputStreamWriter writer1 = new OutputStreamWriter(new FileOutputStream("D:/b.txt"));
// 2. 建立一個字元轉換流物件 (執行編碼: GBK)
OutputStreamWriter writer2 = new OutputStreamWriter(new FileOutputStream("D:/c.txt"), "GBK");
// 3. 寫入資料
writer1.write("我愛上海明珠塔."); // b.txt 22個位元組
writer2.write("我愛上海明珠塔."); // c.txt 15個位元組
// 4. 關閉資源
writer2.close();
writer1.close();
}
}
轉換流理解圖解
轉換流是位元組與字元間的橋樑!
2.5 練習:轉換檔案編碼
將GBK編碼的文字檔案,轉換為UTF-8編碼的文字檔案。
案例分析
- 指定GBK編碼的轉換流,讀取文字檔案。
- 使用UTF-8編碼的轉換流,寫出文字檔案。
案例實現
import java.io.*;
public class Test5 {
public static void main(String[] args) throws IOException {
// 1. 使用 GBK 編碼讀取 Windows 系統上建立的檔案
InputStreamReader reader = new InputStreamReader(new FileInputStream("D:/a.txt"), "GBK");
// 2. 建立一個 UTF-8 編碼的寫入字元轉換流, 按照指定編碼格式將讀取的資料重新寫入到檔案中
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("D:/aa.txt"), "UTF-8");
int read = -1;
while ((read = reader.read()) != -1) {
// 寫入
writer.write(read);
// System.out.println((char) read);
}
writer.close();
reader.close();
}
}
第三章 序列化
3.1 概述
Java 提供了一種物件序列化的機制。用一個位元組序列可以表示一個物件,該位元組序列包含該物件的資料
、物件的型別
和物件中儲存的資料
等資訊。位元組序列寫出到檔案之後,相當於檔案中持久儲存了一個物件的資訊。
反之,該位元組序列還可以從檔案中讀取回來,重構物件,對它進行反序列化。物件的資料
、物件的型別
和物件中儲存的資料
資訊,都可以用來在記憶體中建立物件。看圖理解序列化:
3.2 ObjectOutputStream類
java.io.ObjectOutputStream
類,將Java物件的原始資料型別寫出到檔案,實現物件的持久儲存。
構造方法
public ObjectOutputStream(OutputStream out)
: 建立一個指定OutputStream的ObjectOutputStream。
構造舉例,程式碼如下:
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
序列化操作
- 一個物件要想序列化,必須滿足兩個條件:
條件一 : 序列化介面
- 該類必須實現
java.io.Serializable
介面,Serializable
是一個標記介面,不實現此介面的類將不會使任何狀態序列化或反序列化,會丟擲NotSerializableException
。 - 該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的,則該屬性必須註明是瞬態的,使用
transient
關鍵字修飾。
條件二 : 序列版本號
- 格式 : private static final long serialVersionUID = 1L;
Serializable
介面給需要序列化的類,提供了一個序列版本號。serialVersionUID
該版本號的目的在於驗證序列化的物件和對應類是否版本匹配。
如此,當JVM反序列化物件時,能找到class檔案,如果class檔案在序列化物件之後發生了修改,那麼反序列化操作也不會失敗,如果沒有序列化版本號, 則反序列化會丟擲一個InvalidClassException
異常。
Employee 類定義 :
import java.io.Serializable;
public class Employee implements Serializable {
// 需要為序列化的類新增一個 `序列版本號` 屬性
private static final long serialVersionUID = 1L;
// 屬性
private String name;
private String address;
private transient int age; // 被 transient 修飾的屬性不參與序列化
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
", age=" + age +
'}';
}
// 行為
public void checkAddress() {
System.out.println(name + " = " + address);
}
public Employee(String name, String address, int age) {
this.name = name;
this.address = address;
this.age = age;
}
public Employee() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
2.寫出物件方法
public final void writeObject (Object obj)
: 將指定的物件寫出。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamTest {
public static void main(String[] args) {
// 序列化 : 將一個Java物件儲存到檔案中.
// 1. 建立一個 Employee 物件, 並初始化數值
Employee emp = new Employee("張三", "上海南京西路100號", 30);
// 2. 建立一個物件輸出流
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/emp.txt"))) {
oos.writeObject(emp);
} catch (IOException e) {
// e.printStackTrace();
// 將一個編譯時期的異常轉換為執行時期的異常丟擲.
throw new RuntimeException("序列化物件失敗.");
}
System.out.println("序列化成功!");
}
}
輸出結果:
序列化成功!
3.3 ObjectInputStream類
ObjectInputStream反序列化流,將之前使用ObjectOutputStream序列化的原始資料恢復為物件。
構造方法
public ObjectInputStream(InputStream in)
: 建立一個指定InputStream的ObjectInputStream。
反序列化操作1
如果能找到一個物件的class檔案,我們可以進行反序列化操作,呼叫ObjectInputStream
讀取物件的方法:
public final Object readObject ()
: 讀取一個物件。
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamTest {
public static void main(String[] args) {
// 反序列化 : 將檔案中的資料讀取為一個 Java 物件
// 1. 建立一個物件讀取流
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/emp.txt"))) {
// 2. 讀取檔案中的資料為 Java 物件
Object obj = ois.readObject();
System.out.println(obj);
// 3. 將 obj 型別強轉為 Employee 型別, 並實現方法的呼叫
Employee emp = (Employee) obj;
emp.checkAddress();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
輸出結果 :
Employee{name='張三', address='上海南京西路100號', age=0}
張三 = 上海南京西路100號
對於JVM可以反序列化物件,它必須是能夠找到class檔案的類。如果找不到該類的class檔案,則丟擲一個 ClassNotFoundException
異常。
3.4 練習:序列化集合(使用try-catch)
- 將存有多個自定義物件的集合序列化操作,儲存到
list.txt
檔案中。 - 反序列化
list.txt
,並遍歷集合,列印物件資訊。
案例分析
- 把若干學習物件 ,儲存到集合中。
- 把集合序列化。
- 反序列化讀取時,只需要讀取一次,轉換為集合型別。
- 遍歷集合,可以列印所有的學生資訊
案例實現
Student 類
import java.io.Serializable;
/*
1. 實現 `序列化` 介面
2. 提供 `序列化版本號屬性`
*/
public class Student implements Serializable {
// 屬性
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {