首页手记 Java的序列化与反序列化

Java的序列化与反序列化

标签：

Java

一、概念：
序列化，也称串行化，是把对象写入字节流；反序列化则是从字节流中重构出对象。序列化机制常用于对象的转储或网络传输，以及远程方法的调用。当对象变成字节流后，就可借助对象间的IO来传输，无需考虑接收端是网络还是文件。
二、序列化的实现：
由于任何类都是Object的子类，所以java基于Object类构造了ObjectInputStream和ObjectOutputStream，用于传输Object对象，此时注意，将对象从对象的字节流取出的时候，必须要进行强制类型转换。对象在进行序列化时，各个属性按照定义时的排列顺序。对象中的引用型成员序列化时，在对其进行序列化前，虚拟机会自动搜索与该对象密切相关的其他对象，并建立起一个描述这些对象间关系的网络，称之为对象图(也称对象网)。这样，将对象图中的对象逐个序列化。

实现要点：要实现对象的序列化，则该对象必须实现Serializable接口，该接口没有方法或字段，仅用于标识可以序列化的语义，对于对象中不想被序列化的属性，可用transient修饰。此外Serializable还提供子接口Externalizable，其可以通过readExternal和writerExternal方法指定那些属性将进行序列化。

1、Serializable序列化时不会调用默认的构造器，而Externalizable序列化时会调用默认构造器的！！！
2、Serializable：一个对象想要被序列化，那么它的类就要实现此接口，这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。
Externalizable：他是Serializable接口的子类，有时我们不希望序列化那么多，可以使用这个接口，这个接口的writeExternal()和readExternal()方法可以指定序列化哪些属性。
3、把transient修饰的字段序列化。由于Externalizable对象默认时不保存对象的任何字段，所以transient关键字只能伴随Serializable使用，虽然Externalizable对象中使用transient关键字也不报错，但不起任何作用。
此处摘自CSDN：https://blog.csdn.net/mengtuoling111/article/details/50156307

对象序列化实例：

import java.io.Serializable;

public class Student implements Serializable{
    private String name;
    private int age;
    transient private  String sex;

    public Student() {

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

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

import java.io.*;

public class Main {

    public static void main(String[] args) {

        //序列化对象准备
        Student  s = new Student("tom",22,"boy");
        File file = new File("student.txt");
        try
        {
            file.createNewFile();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }

        try{
            //序列化
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(s);

            objectOutputStream.flush();
            objectOutputStream.close();
            fileOutputStream.close();

            //反序列化
            FileInputStream fileInputStream = new FileInputStream(file);
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            Student s1 = (Student)objectInputStream.readObject();

            System.out.println(s1.getAge());
            System.out.println(s1.getName());
            //被transient修饰属性不被序列化
            System.out.println(s1.getSex());

        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }catch(IOException ex) {
            ex.printStackTrace();
        }
    }
}

所以程序运行结果为：