对象的序列化和反序列化

什么叫做对象的序列化？

　　一个对象产生之后实际上就在内存中开辟了一个存储空间，方便存储信息。

　　对象的序列化就是将一个对象变成二进制的数据流的一种方法，通过对象的序列化可以方便的实现对象的存储和传输。如果一个类的对象需要被序列化，则该类必须实现Serializable接口，该接口的定义如下：

public interface Serializable {
    
}

　　Serializable接口中没有任何方法，只表示该类有这样具备这样一种能力，属于标识接口。下面的一个Student因为实现了Serializable接口，所以它就是可序列化的了：

package io.Serializable;

import java.io.Serializable;

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

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

　　以上的代码仅仅是实现了Serializable接口，其他部分并没有任何改变，以上的类产生的对象就是可序列化（二进制比特流）的了。

如果要进行对象的序列化必须依靠两个类：

ObjectInputStream和ObjectOutputStream

 serialVersionUID

　　在对对象进行序列化和反序列化的时候要考虑到JDK版本的问题，如果序列化的JDK版本和反序列化的JDK版本不统一就会抛出异常。所以在对象序列化的操作中引入了一个serialVersionUID的常量。可以通过此常量验证版本的一致性。在进行反序列化的操作时，JVM会把传来的字节流中的serialVersionUID与本地响应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化的操作，否则就会抛出序列化版本不一致的异常。

　　如果使用Eclipse进行编写，如果没有指定serialVersionUID则会出现一些警告信息，如图：

　　按照Eclipse的提示，我们加上这个常量，这样这个类的设计就完成了。

对象的序列化和反序列化：

package io.Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {

    public static void main(String[] args) {

        File file = new File("E:" + File.separator + "tmp" + File.separator
                + "stu.obj"); // 保存路径
        try {
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream(file));

            Student[] students = { new Student("张三", 12),
                    new Student("李四", 15), new Student("王五", 18) };
            oos.writeObject(students); // 直接写入一个对象数组，因为数组也是对象
            oos.close();

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                    file));
            Student[] stus = (Student[]) ois.readObject();
            ois.close();

            for (Student student : stus) {
                System.out.println(student);
            }

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

    }

}

　　运行结果：

 Externalizable接口

　　被Serializable接口声明的类的对象的内容都能够被序列化，如果现在用户希望可以自己制定序列化的内容，则可以让一个类实现Externalizable接口，该接口的定义如下：

public interface Externalizable extends Serializable {
    public void readExternal(ObjectInput in)throws IOException,ClassNotFoundException;
    public void writeExternal(ObjectOutput out)throws IOException;                  
}

 利用此接口修改之前的程序：

package io.Serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Student implements Externalizable {
    private String name;
    private int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        this.name = (String) in.readObject();    //读取属性
        this.age = in.readInt();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(this.name);    //保存属性
        out.writeInt(this.age);
    }

}

package io.Serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {

    public static void main(String[] args) {

        File file = new File("E:" + File.separator + "tmp" + File.separator
                + "stu.obj"); // 保存路径
        try {
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream(file));

            Student[] students = { new Student("张三", 12),
                    new Student("李四", 15), new Student("王五", 18) };
            oos.writeObject(students); // 直接写入一个对象数组，因为数组也是对象
            oos.close();

            
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                    file));
            Student[] stus = (Student[]) ois.readObject();
            ois.close();

            for (Student student : stus) {
                System.out.println(student);
            }

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

    }

}

　　运行结果：

　　在使用Externalizable接口的时候需要原有的类中有无参构造，在Student类中加入无参构造后一切正常了！此外在Externalizable接口中也可以自定义哪些属性需要序列化，见以下代码：

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        this.name = (String) in.readObject();    //读取属性
//        this.age = in.readInt();
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(this.name);    //保存属性
//        out.writeInt(this.age);
    }

　　以上代码在运行的时候age属性将不会序列化！

transient关键字：

　　在序列化对象的时候如果不需要某个属性被序列化可以使用transient关键字进行修饰。如此一来Externalizable接口就变得毫无用途。

private  transient int age;    //age属性不会被序列化

　　运行结果：

　　由此可见Externalizable接口的功能完全可以由Serializable接口和transient关键字的组合来取代！