为什么使用序列化和反序列化

首先需要了解什么是序列化：

一般程序运行时，产生对象，这些对象随着程序的停止而消失，但如果我们想把某些对象保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象，这种情况下就要用到对象的序列化。

知道了序列化的作用，我们会想到，为什么要用序列化呢？
一座大厦好比一个对象，你要把这座大厦搬到另一个地方去，你想直接挪肯定不行吧？
（一般来说，只有传值，没有传对象。网络传输智能通过字节流，不能直接传输对象），但我可以搬砖头吧，一个一个搬（将对象转成字节流），给砖（字节）用serialVersionUID进行编号，然后搬到目的地，按照编号重新组合成一个大厦，而序列化就起到了将大厦分成砖头的作用，方便数据的交互。

一个类通过实现java.io.Serializable接口（Tag接口，不用具体实现其中的什么方法）来实现序列化和反序列化，将对象转换成一系列字节流，并可以在以后完全恢复回原来的样子。（例如，在Windows上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误的重新“装配”.不必关心数据在不同的机器上如何表示，也不必关心字节的顺序或细节）
可以对序列化后的对象进行读写操作，也可以将序列化后的对象传输于网络。能够解决在对象流进行读写操作时所引发的问题。

序列化主要用来支持2种主要特性（Hibernate和EJB中的实体Bean就用到了序列化的2个特性）：（传递）（保存）
1.RMI（remote method invocation）允许像在本机上一样操作远程机器上的对象。当发送消息给远程对象和调用远程方法时，需要用到序列化机制来发送和接收返回值。
2.保存信息，在某个时刻把信息保存起来，以便以后某个时候恢复这些状态信息。保存的时候不仅能够保存对象的副本，而且还会把对象里面所引用的对象也保存起来，以此类推，即会涉及到用到的所有类，但是，所引用的对象也必须是可序列化的，不然会抛出NotSerializableExceptio异常。

一个序列化的例子：（将对象序列化，再对其反序列化）
对象A：

package woxingwosu;

import java.io.Serializable;

public class A implements Serializable{
    private String name="my name is a";
    private B b=null;
    A(){
        b=new B();
    }
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String show(){
        return "a.toString <a.name=\""+this.name+"\" a.b.name=\""+this.b.getName()+"\">"
            +"\na="+this.toString()+" b="+this.b.toString();
    }
}

对象B：

package woxingwosu;

import java.io.Serializable;

public class B implements Serializable{
    private String name="my name is B";
    B(){}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

将A序列化：

package woxingwosu;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class WriteSeri {
    public static void main(String[] args) {
        ObjectOutputStream outObj=null;
        try{
            FileOutputStream outStr=new FileOutputStream("obj.txt");
            outObj=new ObjectOutputStream(outStr);
            A a=new A();
            outObj.writeObject(a);
            System.out.println("write obj :"+a.show());
            outObj.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(outObj!=null)
                    outObj.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

}

将A反序列化：

package woxingwosu;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ReadSeri {
    public static void main(String[] args) {
        ObjectInputStream inObj=null;
        try{
            FileInputStream inStr=new FileInputStream("obj.txt");
            inObj=new ObjectInputStream(inStr);
            A a=(A)inObj.readObject();
            System.out.println("read Object :"+a.show());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(inObj!=null)
                    inObj.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }

}

首先运行WriteObj，实现序列化，得到输出结果：

write obj :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced

然后运行ReadObj，实现反序列化，得到输出结果：

read Object :a.toString <a.name="my name is a" a.b.name="my name is B">
a=woxingwosu.A@a90653 b=woxingwosu.B@de6ced