对象的序列化和反序列化

1.序列化定义

　　将内存中的java对象放到硬盘文件中（将对象切成一块块的、按序列顺序传输

2.反序列化

　　将硬盘文件中的java对象放到内存中（将对象切成一块块的、按序列顺序传输）

 

                                                        

 3.单个对象的序列化及反序列化

序列化

首先，新建一个类，实现Serializable接口

package bean;

import java.io.Serializable;
//参与序列化的类必须实现Serializable接口，否则会报错
//Serializable只是一个标志接口，接口中什么代码也没有，起到一个标志的作用，java虚拟机看到这个类实现了这个接口，所以会对这个类给予特殊待遇
//Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口后，会为该类自动生成一个序列化版本号
//序列化版本号的用处：
public class Student implements Serializable  {
    
    private int no;
    private String name;
    
    public Student(int no, String name) {
        super();
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [no=" + no + ", name=" + name + "]";
    }
    

}

接下来，进行序列化操作

package IoTest;

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

import bean.Student;

public class ObjectOutputStreamTest {
    
    
    public static void main(String[] args) throws FileNotFoundException, IOException{
        //创建java对象
        Student s=new Student(111,"张三");
        
        //序列化
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("students"));
        
        //序列化对象
        oos.writeObject(s);
        
        oos.flush();
        oos.close();
    }

}

运行结果：

 

 

 

反序列化

package IoTest;

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

public class ObjectInputStreamTest {
    //反序列化
    public static void main(String[] args) throws Exception{
        
            ObjectInputStream oii=new ObjectInputStream(new FileInputStream("students"));
            
            //开始反序列化，读
            Object obj=oii.readObject();
            //反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
            System.out.println(obj);
            
            oii.close();
    }

}

运行结果：

 

 4.多个对象序列化及反序列化

序列化

package IoTest;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

//一次序列化多个对象：可以将对象放到序列化集合中
public class ObjectOutputStreamTest1 {
    
    public static void main(String[] args) throws Exception{
        List<User> userList=new ArrayList<>();
        userList.add(new User(1,"张大狗"));
        userList.add(new User(2,"刘二狗"));
        userList.add(new User(1,"钱小狗"));
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("users"));
        oos.writeObject(userList);
        oos.flush();
        oos.close();
        System.out.println("完成");
    }
    

}

运行结果：

 

 

反序列化

package IoTest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

//反序列化集合
public class ObjectInputStreamTest1 {
    
    public static void main(String[] args) throws Exception{
        
        ObjectInputStream oii=new ObjectInputStream(new FileInputStream("users"));
        List<User>userList=(List<User>)oii.readObject();
        for(User user:userList){
            System.out.println(user.toString());
        }
        oii.close();
        
    }

}

运行结果：

 

 5.若不想使某个属性参与序列化，则可以使用transient关键字

private transient String name;  //若不想使某个属性参与序列化，则可以使用transient关键字

经过序列化--->反序列化操纵后，运行结果为：

 

 

 6.

//过了很久，Student这个类源代码改动了。
    //源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件
    //并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变
    private int st_age;

反序列化后结果：

 

 

 

 

序列化版本号不一致
Exception in thread "main" java.io.InvalidClassException: bean.Student; local class incompatible: 
stream classdesc serialVersionUID = -7370765433862913044（很久之前的序列化版本号）
local class serialVersionUID = -5935280165290247344（现在的序列化版本号）

序列化版本号的作用：
    java中是采用什么机制来区分类的？
    第一：首先通过类名进行比较，如果类名不一样，肯定不是同一个类。
    第二：如果类名一样，则是通过序列化版本号进行区分的。

    A编写了一个类：com.java.bean.Student implements Serializable
    B编写了一个类：com.java.bean.Student implements Serializable
    不用的人编写了同一个类，但是“这两个类确实不是同一个类”，这个时候就需要序列化版本号起作用了。对于java虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，它们的序列化版本号不一样，所以区分开了。这是自动生成序列化版本号的好处。

    思考：自动生成序列化版本号的缺陷？
　　 一旦代码确定后，不能做代码方面的修改，因为只要修改必然会重新编译，此时会生成全新的序列化版本号，此时java虚拟机会认为这是一个全新的类。
　　 结论：所以凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号，这样以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。
　　 　　　建议将序列化版本号手动写出来，不要自动生成
　　 参考ArrayList的固定序列版本号写法：

private static final long serialVersionUID = 8683452581122892189L

public class Student implements Serializable  {
    
    private static final long serialVersionUID =-7370765433862913044; //手动写序列化版本号，使两个序列化版本号保持一致
    private int no;
    private String name;
    //过了很久，Student这个类源代码改动了。
    //源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件
    //并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变
    private int st_age;

反序列化结果：