java中序列化的学习

序列化

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

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

2.ObjectOutputStream类
public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。
一个对象要想序列化，必须满足两个条件:
该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
public final void writeObject (Object obj) : 将指定的对象写出。

package xuliehua;

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;

    public Person(String s) {
    }

    public Person(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;
    }

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

package xuliehua;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class Demo01  {
    public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("day07\\src\\xuliehua\\a.txt");

        ObjectOutputStream os = new ObjectOutputStream(fo);

        Person p = new Person("zhangsan", 18);

        os.writeObject(p);

        os.close();
    }
}

3.ObjectInputStream类
public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。
public final Object readObject () : 读取一个对象。

package xuliehua;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;

public class Demo02 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("day07\\src\\xuliehua\\a.txt");

        ObjectInputStream obs = new ObjectInputStream(fis);

        Person p = (Person)obs.readObject();

        System.out.println(p);

        obs.close();
    }
}

注意被static和transient修饰的内容，不能序列化
4.序列号冲突异常
当类实现Serializable接口后，编译时，根据类的成员变量计算一个long数字（序列号），被保存在.class文件中。当序列化对象时，同时在存储对象的文件中，也保存一份此序列号。

只要修改类的成员，就会重新计算一个long数字（序列号）

当进行反序列化，从文件中读取对象时，会用存储对象中的序列号和.class文件中的序列号做对比，如果不一致，报出序列号冲突。

解决方案
手动指定一个固定的序列号，不管如何修改类的成员，不会重新计算序列号。
private static final long serialVersionUID = 1L;

5.集合的序列化和反序列化

package xuliehua;

import java.io.*;
import java.util.ArrayList;

public class Demo03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        WriteList();
        readList();
    }

    private static void readList() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day07\\src\\xuliehua\\a.txt"));

        ArrayList<Person> list = (ArrayList<Person>) ois.readObject();

        for (Person p:list) {
            System.out.println(p);
        }

        ois.close();
    }

    private static void WriteList() throws IOException {
        Person p1 = new Person("张三", 20);
        Person p2 = new Person("李四", 25);
        Person p3 = new Person("王五", 18);

        ArrayList<Person> list = new ArrayList<>();

        list.add(p1);
        list.add(p2);
        list.add(p3);

        ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("day07\\src\\xuliehua\\a.txt"));

        obs.writeObject(list);

        obs.close();
    }