东风恶、欢情薄，一怀愁绪，几年离索。错！错！错！

——陆游《钗头凤》

IO流之序列化流

1. 概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、 对象的类型 和 对象中存储的数据 等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型 和 对象中存储的数据 信息，都可以用来在内存中创建对象。

看图理解序列化

1564767427547

2. ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

序列化对象。

构造方法

public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

1
2
3
FileOutputStream fileOut = new FileOutputStream("employee.txt");

ObjectOutputStream out = new ObjectOutputStream(fileOut);
序列化操作

一个对象要想序列化，必须满足两个条件:

  1. 该类必须实现 java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
    1. serialVersionUID：序列化的版本号，凡是实现 Serializable 接口的类都有一个静态的表示序列化版本标识符的变量。
  2. 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
1
2
3
4
5
6
7
8
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);
    }
}
写出对象方法

public final void writeObject (Object obj) ; 将指定的对象写出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class SerializeDemo{
    public static void main(String [] args) {
        Employee e = new Employee();
        e.name = "mm";
        e.address = "zz";
        e.age = 17;
        try {
            // 创建序列化流对象
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();
           
            //姓名，地址被序列化，年龄没有被序列化。
            System.out.println("Serialized data is saved"); 
        } catch(IOException i) {
            i.printStackTrace();
        }
    }
}

3. ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

反序列化操作

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用 ObjectInputStream 读取对象的方法.

public final Object readObject () ; 读取一个对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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); // mm
        System.out.println("Address: " + e.address); // zz
        System.out.println("age: " + e.age); // 0
    }
}
反序列化操作–显式添加序列版本号

  • JDK1.8 API的解读

  • 序列化运行时将每个可序列化的类与称为serialVersionUID的版本号相关联，该序列号在反序列化期间用于验证序列化对象的发送者和接收者是否已加载与该序列化兼容的对象的类。 如果接收方加载了一个具有不同于相应发件人类的serialVersionUID的对象的类，则反序列化将导致InvalidClassException 。 一个可序列化的类可以通过声明一个名为"serialVersionUID"的字段来显式地声明它自己的serialVersionUID，该字段必须是静态的，最终的，类型是long 

    1
    ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

  • 如果可序列化类没有显式声明serialVersionUID，则序列化运行时将根据Java（TM）对象序列化规范中所述的类的各个方面计算该类的默认serialVersionUID值。但是，强烈建议所有可序列化的类都明确声明serialVersionUID值，因为默认的serialVersionUID计算对类详细信息非常敏感，这可能会因编译器实现而异，因此可能会在反InvalidClassException化期间导致InvalidClassException的InvalidClassException。因此，为了保证不同Java编译器实现之间的一致的serialVersionUID值，一个可序列化的类必须声明一个显式的serialVersionUID值。

  • 还强烈建议，显式的serialVersionUID声明在可能的情况下使用private修饰符，因为这种声明仅适用于立即声明的类 - serialVersionUID字段作为继承成员无效。

  • 数组类不能声明一个显式的serialVersionUID，所以它们总是具有默认的计算值，但是对于数组类，放弃了匹配serialVersionUID值的要求。

1
2
3
4
5
6
7
8
9
10
11
12
13
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);
    }
}

4. 练习–序列化集合

  1. 将存有多个自定义对象的集合序列化操作，保存到 list.txt 文件中。

  2. 反序列化 list.txt ，并遍历集合，打印对象信息。

案例分析

  1. 把若干学习对象 ，保存到集合中。

  2. 把集合序列化。

  3. 反序列化读取时，只需要读取一次，转换为集合类型。

  4. 遍历集合，可以打印所有的学生信息

案例实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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();
    }
}

☆