文章目录
序列化
常见问题
标志性接口
序列化版本号有什么用？
序列化对象
Student
main
实现截图
序列化集合
反序列化
反序列化对象
反序列化集合
判断反序列化是否是集合
反序列化集合代码
注意
transient
Student类
注意
反序列化代码
序列化代码
执行结果
name为NULL解释：
序列化版本号有什么用？
java语言中是采用什么机制来区分类的？
举例讲解
这种自动生成序列化版本号有什么缺陷？
IDEA自动生成序列化版本号
如下操作
最终结论：
序列化
1.序列化：Serialize java对象存储到磁盘文件中，将java对象的状态保存下来的过程
(ObjectOutputStream)(从内存到硬盘，也就是输出)
2.参与序列化和反序列化对象，必须实现Serializable接口，只是一个标志接口
java中有两种接口：
普通接口
标志接口(标志接口都是没有方法的)
常见问题
报错原因是：所需序列化的类对象并没有继承接口Serializable
然后按下ctrl + b可以查看这个接口Serializable源码
标志性接口
很显然，这是一个标志性接口
注意：通过源代码发现，Serializable接口只是一个标志接口：
public interface Serializable{
}那么这个接口中当中什么都没有
那么它到底起什么作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。
Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号
序列化版本号有什么用？
过了很久，序列化原来那个类源代码改动了，
源代码改动了之后，需要重新编译，编译之后生成了全新的字节码文件
并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会随之发生相应的改变
序列化对象
Student
import java.io.Serializable;
public class Student {
private int no;
private String name;
public Student(){
}
public Student(int no ,String name ){
this.name=name;
this.no=no;
}
public int getNo() {
return no;
}
public String getName() {
return name;
}
public void setNo(int no) {
this.no = no;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}
main
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectOutputStreamTest01 implements Serializable {
public static void main(String[] args) throws Exception{
//创建java对象
Student s=new Student(111,"豪哥");
//序列化
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("students"));
//序列化对象
oos.writeObject(s);
//刷新
oos.flush();
//关闭
oos.close();
}
}实现截图
序列化集合
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class ObjectOutputStreamTest01 {
public static void main(String[] args) throws Exception{
//创建对象list集合
ListuserList=new ArrayList<>();
userList.add(new Student(1,"莫老板"));
userList.add(new Student(2,"戴总"));
userList.add(new Student(3,"彪彪"));
//序列化
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("students"));
//序列化对象
oos.writeObject(userList);
//刷新
oos.flush();
//关闭
oos.close();
}
}
反序列化
反序列化：DeSerialize 将硬盘上的数据重新恢复到内存当中，恢复成java对象(ObjectInputStream)(从硬盘到内存，也就是输入)
反序列化对象
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamtTest01 {
public static void main(String[] args) throws Exception{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("students"));
//开始序列化，读
Object obj=ois.readObject();
//反序列化回来是一个学生对象，所以会调用学生对象的toString方法
System.out.print(obj);
ois.close();
}
}
反序列化集合
判断反序列化是否是集合
首先利用代码判断，反序列的东西，是否是集合：
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;
public class ObjectInputStreamtTest01 {
public static void main(String[] args) throws Exception{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("students"));
//开始序列化，读
Object obj=ois.readObject();
System.out.print(obj instanceof List);
ois.close();
}
}
反序列化集合代码
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;
public class ObjectInputStreamtTest01 {
public static void main(String[] args) throws Exception{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("students"));
ListuserList=(List) ois.readObject();
//反序列化回来是一个学生对象，所以会调用学生对象的toString方法
for(Student student:userList){
System.out.print(student);
}
ois.close();
}
}
注意
如果不用集合，直接存多个对象，那么存第二个对象会报错的，需要使用List集合
transient
transient 关键字表示游离的，不参与序列化
Student类
import java.io.Serializable;
public class Student implements Serializable {
private int no;
transient private String name;
public Student(){
}
public Student(int no ,String name ){
this.name=name;
this.no=no;
}
public int getNo() {
return no;
}
public String getName() {
return name;
}
public void setNo(int no) {
this.no = no;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
}注意
name前面加了个transient关键字
反序列化代码
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;
public class ObjectInputStreamtTest01 {
public static void main(String[] args) throws Exception{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("students"));
ListuserList=(List) ois.readObject();
//反序列化回来是一个学生对象，所以会调用学生对象的toString方法
for(Student student:userList){
System.out.print(student);
}
ois.close();
}
}序列化代码
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class ObjectOutputStreamTest01 {
public static void main(String[] args) throws Exception{
ListuserList=new ArrayList<>();
userList.add(new Student(1,"莫老板"));
userList.add(new Student(2,"戴总"));
userList.add(new Student(3,"彪彪"));
//创建java对象
Student s=new Student(4,"豪哥");
//序列化
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("students"));
//序列化对象
oos.writeObject(userList);
//刷新
oos.flush();
//关闭
oos.close();
}
}执行结果
当执行序列化后，再来执行反序列结果后：结果如下：
name为NULL解释：
因为开始时，设置了name是不参加序列化的，所以name并没有序列化到文件中，但是最终在反序列化时，需要new对象，new三个user对象，name没有值，然后就为默认值NULL
序列化版本号有什么用？
过了很久，序列化原来那个类源代码改动了，
源代码改动了之后，需要重新编译，编译之后生成了全新的字节码文件
并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会随之发生相应的改变
private static final long serialVersionUID=1L;java语言中是采用什么机制来区分类的？
首先通过类名进行对比，如果类名不一样，肯定不是同一个类
如果类名一样，再怎么进行类的区别？靠序列化版本号进行区分
举例讲解
小鹏编写了一个类：com.bjpowernode.java.bean.Student implements Serializable
小李编写了一个类：com.bjpowernode.java.bean.Student implements Serializable
对于不同的人编写了同一个类，但这两个类确实不是同一个类。这个时候序列化版本就起上了作用。对于java虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本不一样，所以区分开了(这是自动生成序列化版本号的好处)
这种自动生成序列化版本号有什么缺陷？
不能修改原来的序列化类对象的代码，只要一修改代码，那么就无法反序列化(一旦代码确定之后，不能就行后续的修改，因为只要修改，必然会重新编译，此时就会生成全新的序列化版本号，这时候java虚拟机会认为这是个全新的类)
IDEA自动生成序列化版本号
勾选之后呢，点击ok
如下操作
当这个类没有手动添加序列化版本时，把鼠标放在Student上，然后点击Alt+回车
点击第一个后
就会自动生成一串序列化版本号喽
最终结论：
凡是实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
