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()方法读取对象。

  

下面让我们来看一个对应的例子，类的内容如下：

 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;   }   } <pre name="code" class="java"> public class Customer implements Serializable {
    /**
     *  @author 奮鬥中德菜鳥
     *   版权所有,并保留所有权利。
     */
    private static final long serialVersionUID = 1L;
    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;
    }
}

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();            
     }
}

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)序列化：将该对象写出到对象输出流，那么用对象输入流读回的对象就是原对象的一个深度克隆

深度克隆类：

import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
 
public class DepthClone { 
     
    public  final static Object objectCopy(Object oldObj) { 
        Object newObj = null; 
         
        try { 
            ByteArrayOutputStream bo = new ByteArrayOutputStream(); 
            ObjectOutputStream oo = new ObjectOutputStream(bo); 
            oo.writeObject(oldObj);//源对象 
            ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray()); 
            ObjectInputStream oi= new ObjectInputStream(bi); 
            newObj = oi.readObject();//目标对象 
        } catch (IOException e) { 
            e.printStackTrace(); 
        }catch (ClassNotFoundException e) { 
            e.printStackTrace(); 
        } 
         
        return newObj; 
    } 
} 
 

 
浅度克隆类：
Java代码 :

import java.io.Serializable; 
 
public class SimpleClone implements Cloneable ,Serializable { 
 
    private static final long serialVersionUID = -7552721152118950502L; 
     
    public    String s = null; 
    public Object o = null; 
    public CloneObject cloneObject = null; 
     
     
    public SimpleClone(CloneObject cloneObject) { 
        this.cloneObject = cloneObject; 
    } 
 
    public Object clone() { 
        SimpleClone newSimpleClone =  null; 
        try { 
            /* 浅克隆 */ 
            newSimpleClone = (SimpleClone)super.clone(); 
        } catch (CloneNotSupportedException e) { 
            e.printStackTrace(); 
        } 
        return newSimpleClone; 
    } 
}