对象的序列化和反序列化

什么是序列化？
为了把对象的成员属性和成员方法进行持久化的保存，需要把对象转换为字节序列，以便于存储，这个过程就叫序列化。

反之，反序列化就是把字节序列恢复成对象。

1. 实现序列化的对象需要实现一个标记接口，并且给这个添加一个Long类型的标记

Serializable 这个接口里面没有任何东西，只是作为一个标记
private static final long serialVersionUID = 1L;常量，默认设置为1L

当我们进行序列化和反序列化时就会检测该类上面是否有这个标记，没有会抛出异常 NotSerializableException

2. 使用ObjectOutputStream类writeObject()方法写入对象

public class ObjectOutputStream
    extends OutputStream implements ObjectOutput, ObjectStreamConstants{
    }

该类继承了字节流的输出流OutputStream类

3. 要读取时，使用ObjectInputStream类的readObject()方法

public class ObjectInputStream
    extends InputStream implements ObjectInput, ObjectStreamConstants
{}

该类继承字节流的输入流InputStream类

package com.study.SerializableImpl;

import java.io.Serializable;

/**
 * @Description 实现对象序列化
 * @Date 2021/9/12 13:09
 * @Created by 折腾的小飞
 */
public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

package com.study.SerializableImpl;

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

/**
 * @Description 3种方法实现对象的反序列化
 * @Date 2021/9/12 14:23
 * @Created by 折腾的小飞
 */
public class StudentSerializable {
    public static void main(String[] args) {
        Student stu = new Student("胡梓卓", 22);
        Student stu1 = new Student("涂鏊飞", 21);
        Student[] stus = {stu, stu1};
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./stu.txt")));

            /*oos.writeObject(stus); // 写入一个对象数组
            oos.flush();*/

            // 遍历写入单个对象
            /*for (Student student : stus) {
                oos.writeObject(student);
                oos.flush();
            }
            oos.writeObject(null);*/

            for (Student student : stus) {
                oos.writeObject(student);
                oos.flush();
            }

            System.out.println("对象序列化成功");


            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./stu.txt"));
            // 存入文件时，将几个对象放入一个Object[] 数组中，然后再读取。
            /*Object[] arrStu = (Object[]) ois.readObject();
            for (Object o : arrStu) {
                System.out.println(o);
            }*/


            // 第二种方法，在写入时最后写入null
            /*Student s=null;
            while ((s= (Student) ois.readObject())!=null){
                System.out.println(s);
            }*/

            // 用available判断是否达到了文件末尾
            /*Object obj = null;
            while (ois.available() > 0) {
                obj = ois.readObject();
                System.out.println(obj);
            }*/

            /*System.out.println(ois.available());*/
            System.out.println("对象反序列化成功");
            oos.close();
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

把两个对象stu和stu1写入文件stu.txt后，查看文件

�� sr "com.study.SerializableImpl.Student        L aget Ljava/lang/Integer;L namet Ljava/lang/String;xpsr java.lang.Integer⠤���8 I valuexr java.lang.Number������  xp   t 	胡梓卓sq ~  sq ~    t 	涂鏊飞