【Java】序列化和反序列化

序列化和反序列化

1.定义

Java序列化就是指把Java对象转换为字节序列的过程
Java反序列化就是指把字节序列恢复为Java对象的过程。

2.作用
序列化最重要的作用：在传递和保存对象时，保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。
反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

3.实现序列化和反序列化的过程

1、实现序列化的必备要求：

只有实现了Serializable或者Externalizable接口的类的对象才能被序列化为字节序列。（不是则会抛出异常）

2、JDK中序列化和反序列化的API：

  ①java.io.ObjectInputStream：对象输入流。

      该类的readObject()方法从输入流中读取字节序列，然后将字节序列反序列化为一个对象并返回。

 ②java.io.ObjectOutputStream：对象输出流。

      该类的writeObject(Object obj)方法将将传入的obj对象进行序列化，把得到的字节序列写入到目标输出流中进行输出。

3、实现序列化和反序列化的三种实现：

①若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

         ObjectOutputStream采用默认的序列化方式，对Student对象的非transient的实例变量进行序列化。 
         ObjcetInputStream采用默认的反序列化方式，对Student对象的非transient的实例变量进行反序列化。

②若Student类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。
ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。
ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

③若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。 
ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

import java.io.Serializable;           
 

public class Student implements Serializable {
   
    private String name;
    private  char sex;
    private  int year;
    private  double gpa;
 
    public Student(){   
    }
    public Student(String name,char sex,int year,double gpa){
       
        this.name = name;
        this.sex = sex;
        this.year = year;
        this.gpa = gpa;
    }
 
    
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public char getSex() {
        return sex;
    }
 
    public void setSex(char sex) {
        this.sex = sex;
    }
 
    public int getYear() {
        return year;
    }
 
    public void setYear(int year) {
        this.year = year;
    }
 
    public double getGpa() {
        return gpa;
    }
 
    public void setGpa(double gpa) {
        this.gpa = gpa;
    }
}

import java.io.*;
import java.io.Externalizable;

public class UserStudent {
    public static void main(String[] args) throws IOException {
        Student st = new Student("Tom",'M',20,3.6);        
        File file = new File("E:\\JavaXuLiehua\\Student\\Student1.txt");
        if(file.exists()) {
            System.out.println("文件存在");
        }else{
           
            file.createNewFile();
        }
        try {
            //Student对象序列化过程
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //调用 ObjectOutputStream 中的 writeObject() 方法 写对象
            oos.writeObject(st);
            oos.flush();        
            fos.close();
            oos.close();
 
            //Student对象反序列化过程
            FileInputStream fis = new FileInputStream(file);
            //创建对象输入流
            ObjectInputStream ois = new ObjectInputStream(fis);
            
            Student st1 = (Student) ois.readObject();           
            System.out.println("name = " + st1.getName());
            System.out.println("sex = " + st1.getSex());
            System.out.println("year = " + st1.getYear());
            System.out.println("gpa = " + st1.getGpa());
            ois.close();
            fis.close();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}