java 序列化 浅克隆 深克隆

序列化
   Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。
    当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。
    把Java对象转换为字节序列的过程称为对象的序列化。
    把字节序列恢复为Java对象的过程称为对象的反序列化。
1、序列化的用途
    利用对象的序列化可以保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。
     对象的序列化主要有两种用途：
（a） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
（b） 在网络上传送对象的字节序列。
2、序列化的实现
（1）JDK类库中的序列化API
    java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
     java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
     只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。
（2）对象序列化与反序列化的过程
     将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
     对象序列化包括如下步骤：
（a）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
（b）通过对象输出流的writeObject()方法写对象。
     对象反序列化的步骤如下：
（a）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
（b）通过对象输入流的readObject()方法读取对象。
     下面让我们来看一个对应的例子，类的内容如下：


Java代码
import java.io.*;  
import java.util.Date;  
public class ObjectSaver {  
          public static void main(String[] args) throws Exception {  
              ObjectOutputStream out = new ObjectOutputStream  
                     (new FileOutputStream("D:""objectFile.obj"));  
              //序列化对象  
              Customer customer = new Customer("阿蜜果", 24);  
              out.writeObject("你好!");  
              out.writeObject(new Date());  
              out.writeObject(customer);  
              out.writeInt(123); //写入基本类型数据  
              out.close();  
              //反序列化对象  
              ObjectInputStream in = new ObjectInputStream  
                     (new FileInputStream("D:""objectFile.obj"));  
              System.out.println("obj1=" + (String) in.readObject());  
              System.out.println("obj2=" + (Date) in.readObject());  
              Customer obj3 = (Customer) in.readObject();  
              System.out.println("obj3=" + obj3);  
              int obj4 = in.readInt();  
              System.out.println("obj4=" + obj4);  
              in.close();  
       }  
}  
class Customer implements Serializable {  
       private String name;  
       private int age;  
       public Customer(String name, int age) {  
              this.name = name;  
              this.age = age;  
       }  
       public String toString() {  
              return "name=" + name + ", age=" + age;  
       }  
}  
import java.io.*;
import java.util.Date;
public class ObjectSaver {
public static void main(String[] args) throws Exception {
ObjectOutputStream out = new ObjectOutputStream
(new FileOutputStream("D:""objectFile.obj"));
//序列化对象
Customer customer = new Customer("阿蜜果", 24);
out.writeObject("你好!");
out.writeObject(new Date());
out.writeObject(customer);
out.writeInt(123); //写入基本类型数据
out.close();
//反序列化对象
ObjectInputStream in = new ObjectInputStream
(new FileInputStream("D:""objectFile.obj"));
System.out.println("obj1=" + (String) in.readObject());
System.out.println("obj2=" + (Date) in.readObject());
Customer obj3 = (Customer) in.readObject();
System.out.println("obj3=" + obj3);
int obj4 = in.readInt();
System.out.println("obj4=" + obj4);
in.close();
}
}
class Customer implements Serializable {
private String name;
private int age;
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "name=" + name + ", age=" + age;
}
}
输出结果如下：

Java代码

obj1=你好!  
obj2=Sat Sep 26 22:02:21 CST 2010  
obj3=name=阿蜜果, age=24  
obj4=123  
obj1=你好!
obj2=Sat Sep 26 22:02:21 CST 2010
obj3=name=阿蜜果, age=24
obj4=123
      因此例比较简单，在此不再详述。
3、serialVersionUID作用：
      序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
       有两种生成方式：
       一个是默认的1L，比如：

Java代码
private static final long serialVersionUID = 1L;  
private static final long serialVersionUID = 1L;
       一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：

Java代码
private static final   long      serialVersionUID = xxxxL; 
private static final   long      serialVersionUID = xxxxL;
二、克隆
      有时想得到对象的一个复制品，该复制品的实体是原对象实体的克隆。复制品实体的变化不会引起原对象实体发生变化，这样的复制品称为原对象实体的克隆对象或简称克隆。
1、浅复制（浅克隆）
      概念：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
      方法：类implements Cloneable，然后重写clone()方法，在clone()方法中调用super.clone()即可，没有其他操作了
2、深复制（深克隆）
      概念：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍
      方法：
（1）类implements Cloneable，然后重写clone()方法，在clone()方法中调用super.clone()，然后还要对引用型变量所指的对象进行克隆。
（2）序列化：将该对象写出到对象输出流，那么用对象输入流读回的对象就是原对象的一个深度克隆