10JavaSE缓冲流、转换流、序列化流、Files

2016-11-28 PV:

第一章属性集

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)：从字节输入流中读取键值对。

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

1
2
3

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编码。它使用一至四个字节为每个字符编码，编码规则：
  1. 128个US-ASCII字符，只需一个字节编码。
  2. 拉丁文等字符，需要二个字节编码。
  3. 大部分常用字（含中文），使用三个字节编码。
  4. 其他极少使用的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): 创建一个指定字符集的字符流。

构造举例，代码如下：

1 2	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): 创建一个指定字符集的字符流。

构造举例，代码如下：

1 2	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。

构造举例，代码如下：

1 2	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("张三", "爱尔兰大白鲨", 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='爱尔兰大白鲨', age=0}
张三 = 爱尔兰大白鲨

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

第四章打印流

4.1 概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

4.2 PrintStream类

构造方法

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

构造举例，代码如下：

1	PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个”小把戏”，改变它的流向。

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintStreamTest {
    public static void main(String[] args) throws FileNotFoundException {

        PrintStream ps = new PrintStream("D:/ps.txt");

        // 技巧 : 设置系统的打印流方向
        System.setOut(ps);

        // 输出数据
        System.out.println("Who are you？");
        System.out.println("你是谁？");
    }
}

第一章 属性集

1.1 概述

1.2 Properties类

构造方法

基本的存储方法

与流相关的方法

第二章 转换流

2.1 字符编码和字符集

字符编码

字符集

2.2 编码引出的问题

2.3 InputStreamReader类

构造方法

指定编码读取

2.4 OutputStreamWriter类

构造方法

指定编码写出

转换流理解图解

2.5 练习：转换文件编码

案例分析

案例实现

第三章 序列化

3.1 概述

3.2 ObjectOutputStream类

构造方法

序列化操作

3.3 ObjectInputStream类

构造方法

反序列化操作1

第四章 打印流

4.1 概述

4.2 PrintStream类

构造方法

改变打印流向

第一章属性集

第二章转换流

第三章序列化

第四章打印流