序列化与反序列化ObjectInputStream和ObjectOutputStream

---

前言

序列化Serialize：将内存的对象存储到硬盘中。
反序列化DeSerialize：将硬盘中的数据恢复到内存中。

---

创建对象类时，若想序列化对象，需要让此类实现Serializable接口，每一个实现了Serializable接口的类，Java虚拟机会自动生成一个序列化版本号。

一、序列化版本号的作用

用来区分类。
Java虚拟机去分类时：
（1）先通过类名（2）类名一致时，通过序列化版本号区别

二、自动生成的序列号缺点

1.缺点

一旦代码确定之后，不能进行后续的修改，
因为只要一修改，必然会重新编译，此时会生成新的序列号，
Java虚拟机会认为这是一个新类。

2.优化

建议手动写出序列化版本号：
private static final long serialVersionUID = 序列化号L;

transient关键字

表示游离的，属性不参与序列化。

序列化和反序列化多个对象实例

对象类User

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = -6507414625707703261L;
    private transient int id;
    private String name;

    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

序列化

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class SerializeIo {
    public static void main(String[] args) {
        List<User> list = new ArrayList<>();
        list.add(new User(111,"zhangsan"));
        list.add(new User(111,"zhangsan"));
        list.add(new User(111,"zhangsan"));

        //创建对象字节输出流
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("userIO"));
            //序列化，开始往硬盘中写文件
            oos.writeObject(list);
            //刷新
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

反序列化

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

public class DeSerializeIo {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("userIO"));
            //反序列化，开始从硬盘中缓存数据
            List<User> list = (List) ois.readObject();
            for (User user : list){
                System.out.println(user);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally{
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}