Java语法-序列化流和反序列化流

1、什么叫序列化流和反序列化流？

把对象以流的方式，写入到文件中保存，叫做写对象或对象的序列化；
用字节流 —— ObjectOutputStream(对象的序列化流)
writeObject( p );

---

把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫做对象的反序列化；
用字节流 —— ObjectInputStream(对象的反序列化流)
用字节流；
readObject()

2、ObjectOutputStream 代码实现

import java.io.Serializable;

/*
    序列化和反序列化，抛出异常NotSerializableException
    要实现序列化和反序列化的类要实现 Serializable 接口
*/
public class Person implements Serializable{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
    继承：OutputString
    构造方法：ObjectOutputStream(OutputStream out)
        参数：OutputStream out 字节输出流
    成员方法：writeObject(Object obj)
 */
public class ObjectOutputStreamTest {
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        oos.writeObject(new Person("James",18));
        oos.close();
    }
}

总结：
Serializable是一种标记型接口，相当于生猪上盖的食品安全的章；

3、ObjectInputStream 代码实现

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

/*
    继承：InputStream
    构造方法：ObjectInputStream(InputStream in)
        参数：InputStream in 字节输入流
    成员方法：readObject(p)
 */
public class ObjectInputStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        Object obj = ois.readObject();
        ois.close();
        System.out.println(obj);
        // 将文件里的对象转换成Person对象
        Person p = (Person)obj;
        System.out.println(p.getName()+" " + p.getAge());
    }
}

4、transient 关键字有什么用？

提到 transient 的关键字，类比 static 关键字；
static 关键字修饰成员变量时，静态的成员变量优先于对象进入内存中保持静止不再改变；
因此被static 修饰的成员变量不能被序列化，就是说不能被赋值；
transient 关键字又叫 瞬态关键字；
被transient 修饰的成员变量，不能被序列化；
想成员变量不想被序列化，用 transient;

5、序列化和反序列化的直观形式是什么？

序列化就是执行一遍 ObjectOutputStreamTest.java
反序列化就是执行一遍 ObjectInputStreamTest.java

6、序列号冲突异常是如何产生的？

javac.exe编译器把Person.java文件编译生成java.class文件；
因为Person类实现了Serializable接口，根据类的定义，给Person.class添加了一个序列号 —— serialVersionUID;
Person.class经过序列化以后变为 Person.txt，序列号不变；
反序列化的时候会将Person.txt的序列号和当下的Person.class的序列号进行比对，相同则成，不相同则失败；
当下的Person.class为什么和之前的Person.class的序列号不同呢？
因为Person类的定义改变了，而且重新编译了生成了新的Person.class覆盖了原来的。
想要无论是否对类的定义发生修改，都可以顺利反序列化，那么在类中添加 —— static final long serialVersionUID = xxL;

7、序列化集合的代码实现

序列化集合是想在文件保存多个对象，将多个对象存储到一个集合中；

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

public class Test3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("kobe",42));
        list.add(new Person("james",35));
        list.add(new Person("dong77",20));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        oos.writeObject(list);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
        Object obj = ois.readObject();
        ArrayList<Person> list2 = (ArrayList<Person>)obj;
        for (Person p : list2) {
            System.out.println(p);
        }
        ois.close();
        oos.close();
    }
}

总结：
writeObject()里面可以写集合，感觉方法如其名，只要是个对象都能放进去；
反序列化之后的类型是Object，想要把它当集合使用，需要先强制类型转换；