Java总结10 对象序列化 即:对象输出流 与 对象反序列化 即:对象输入流

一/对象序列化

对象序列化 即:对象输出
将某个对象以字节的方式写入到硬盘
创建格式:ObjectOutputStream 自定义对象序列化对象名 = new ObjectOutputStream(new FileOutputStream(具有对象内容的文件之路径/File对象));
列如:ObjectOutputStream objectOutputStreamObj = new ObjectOutputStream(new FileOutputStream("\ObjOutputStream.txt"));
方法应用:
1/ 格式:自定义对象序列化对象名.writeObject(要输出到硬盘的对象名);
列如:objectOutputStreamObj.writeObject(studentObj);
意义:将括号内的对象输出到以字节文件的方式输出到硬盘.

二/对象反序列化

对象反序列化 即:对象输入
将某个存有对象的硬盘文件读入到内存中.
注意:被读入的文件必须为对象序列化文件,也就是存有对象内容的文件,如果被读入的文件非[对象序列化文件]则会报错.
创建格式:ObjectInputStream 自定义对象反序列化对象名 = new ObjectInputStream(new FileInputStream(具有对象内容的文件之路径/File对象));
列如:ObjectInputStream objectInputStreamObj = new ObjectInputStream(new FileInputStream("\testB.txt"));
方法应用:
步骤1/ 将读取到的对象赋值给左侧的变量,变量类型为Obj,尽管你知道这个对象是什么类型,但出于保险起见还是为Object为好.
格式:Object 自定义Obj类型变量名 = 自定义对象反序列化对象名.readObject();
列如:Object readObj = objectInputStreamObj.readObject();
步骤2/ 将存有对象的Object型变量强制转换成对象的原本类型,并赋值给左侧的变量.
格式:对象的原本类型 自定义原本类型变量名 = (对象的原本类型)自定义Obj类型变量名;
列如: Student readObjOfStudent = (Student)readObj;

三/serialVersionUID(serialVersionUIDtransient)

意义:假如你在把隶属于该类的对象(旧版本类对象)写出后,却更改了该类的成员变量或其它内容(新版本类对象),那么再次读入该类对象的话,就会报错.
因此,为了确定输出后的类对象跟其所属的类是兼容的,所以出现了’serialVersionUID’,sseriaVersionUID可以给类中赋一个,
如果输出后的类对象的UID同目前其所属类的UID是相同的,则说明是兼容的,反之则不是兼容的.
步骤1/ 对象类必须继承Serializable标识接口,才可使用UID,所谓标识,顾名思义就是要让JAVA知道,该对象类具有UID识别的功能.
格式:类权限修饰符 class 类名 implements Serializable{}
列如:public class Student implements Serializable {}
步骤二/ 声明一个UID值,以用来识别.
格式:成员变量权限修饰符 static final long serialVersionUID = 数值L;
列如:public static final long serialVersionUID = 23L;

演示:Main主方法类

public class ObjectOfSerialize {
    public static void main(String[] args) throws Exception {

        //对象序列化 即:对象输出
        ObjectOutputStream objectOutputStreamObj = new ObjectOutputStream(new FileOutputStream("\\ObjOutputStream.txt"));
        Student studentObj = new Student("中国", 5000);
        Student studentObjTwo = new Student("美国", 300);


        objectOutputStreamObj.writeObject(studentObj);
     //   objectOutputStreamObj.writeObject(studentObjTwo);

        //对象反序列化 即:对象输入
        ObjectInputStream objectInputStreamObj = new ObjectInputStream(new FileInputStream("\\ObjOutputStream.txt"));
        Object readObj = objectInputStreamObj.readObject();
        Student readObjOfStudent = (Student)readObj;



    }
}

演示:Student学生类

import java.io.Serializable;

public class Student implements Serializable {

    public static final long serialVersionUID = 23L;
    /*
    serialVersionUID(serialVersionUIDtransient)
格式:权限修饰符 static final long serialVersionUID = 23L;
列如:public static final long serialVersionUID = 23L;
意义:假如你在把隶属于该类的对象(旧版本类对象)写出后,却更改了该类的成员变量或其它内容(新版本类对象),那么再次读入该类对象的话,就会报错.
     因此,为了确定输出后的类对象跟其所属的类是兼容的,所以出现了'serialVersionUID',sseriaVersionUID可以给类中赋一个,
     如果输出后的类对象的UID同目前其所属类的UID是相同的,则说明是兼容的,反之则不是兼容的.

     */
    private String name;
    private int 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;
    }

    public Student() {
    }

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

四/通过让实体类实现Serializable接口默认开启序列化操作

Serializable接口是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。

这个介绍非常的不接地气，于是我与去看了几篇博客，有一个小姐姐的博客引起了我的注意，她是这样理解的：

序列化的过程，就是一个“freeze”的过程，它将一个对象freeze（冷冻）住，然后进行存储，等到再次需要的时候，再将这个对象de-freeze就可以立即使用。

我们以为的没有进行序列化，其实是在声明的各个不同变量的时候，由具体的数据类型帮助我们实现了序列化操作。

如果有人打开过Serializable接口的源码，就会发现，这个接口其实是个空接口，那么这个序列化操作，到底是由谁去实现了呢？其实，看一下接口的注释说明就知道，当我们让实体类实现Serializable接口时，其实是在告诉JVM此类可被序列化，可被默认的序列化机制序列化。

https://www.cnblogs.com/wangenxian/p/11003221.html