java的对象复制 --整理总结版

Java 中的赋值操作符与 C++ 中的不一样。在 C++ 中，这条语句：bc2 = bc1;将一个名为 bc1 的对象的所有数据都拷贝到名为 bc2 的对象中。也就是说这条语句执行后，程序中有两个含有相同数据的对象。然而在 Java 中，这条相同的赋值语句只向 bc2 中拷贝了 bc1 指向的存储地址，现在 bc1 和 bc2 实际上指的是同一个对象，它们都是这个对象的引用。这样大大提高了内存使用效率，同时也容易让一些对内存了解不深的朋友带来一些使用上的错误。比如 bc1.add(25);buc2.add(20);执行之后 bc1 增加了 45。而作者本意可能是只是让 bc1 增加 25，bc2 增加 20 而已。这说明了，在 Java 中，bc2 = bc1; 并不是真正意义上的复制。那么在 Java 中如何进行对象复制呢？作者结合 Java 数据结构相关知识，总结了一些项目中的经验，希望可以和大家共同探讨一下这个问题。

        没有使用对象复制的代码：

        银行帐户源代码 BankAccount.java：

    package clone;      public class BankAccount{          private double balance;          public BankAccount(double ini){              this.balance = ini;          }                    public double getBalance() {              return balance;          }          public void setBalance(double balance) {              this.balance = balance;          }          public void add(double give){              this.balance += give;          }                    public void redu(double give){              this.balance -= give;          }      }  

  程序入口 TestClone.java：

    package clone;      public class TestClone {          public static void main(String[] args) {              BankAccount bc1 = new BankAccount(1000.0);              BankAccount bc2 = bc1;              bc1.add(25);              bc2.add(20);              System.out.println("用户 1 的帐户余额为：" + bc1.getBalance());              System.out.println("用户 2 的帐户余额为：" + bc2.getBalance());          }      }  

执行 TestClone.java，打印结果如下：
用户 1 的帐户余额为：1045.0
用户 2 的帐户余额为：1045.0
        这下用户 2 要哭了：自己辛辛苦苦攒的一点钱都存别人帐户里边去了。怎么解决这个问题呢？用户 2 不应该使用等号，而应该进行对象复制。那么在 Java 中怎样进行对象复制呢？有两种办法。
        Java 中对象的复制办法一        一开始就创建两个不同的对象，然后分别拷贝每一个字段。注意：等号是不起复制作用的！这里说的拷贝并非用等号进行，而是手工复制。代码说明如下。
        银行帐户源代码不变 BankAccount.java：

    package clone;      public class BankAccount{          private double balance;          public BankAccount(double ini){              this.balance = ini;          }                    public double getBalance() {              return balance;          }          public void setBalance(double balance) {              this.balance = balance;          }          public void add(double give){              this.balance += give;          }                    public void redu(double give){              this.balance -= give;          }      }  

  在程序入口 TestClone.java 中进行对象复制：

    package clone;      public class TestClone {          public static void main(String[] args) {              BankAccount bc1 = new BankAccount(1000.0);              BankAccount bc2 = new BankAccount(1000.0);              bc1.add(25);              bc2.add(20);              System.out.println("用户 1 的帐户余额为：" + bc1.getBalance());              System.out.println("用户 2 的帐户余额为：" + bc2.getBalance());          }      }  

执行 TestClone.java，打印结果如下：
用户 1 的帐户余额为：1025.0
用户 2 的帐户余额为：1020.0
        用户 2 终于把自己挣的血汗钱存入了自己的帐户里去了。但是 Java 程序员要哭了：这里只是一个简单的例子，如果对象比较复杂，每次都要复制，而且还要处处考虑是不是又进行赋值引用了？这岂不麻烦？为了克服这个问题，Java 引入了克隆的概念。
        Java 中对象的复制办法二        使用克隆进行对象复制。Java API 里解释：java.lang.Object.clone() 可以创建一个当前实例的拷贝。前提是当前实例的对象必须实现 java.lang.Cloneable 接口，然后再重载 java.lang.Object 的 clone 方法。代码说明如下。
        银行帐户源代码 BankAccount.java：

    package clone;      public class BankAccount implements Cloneable{          private double balance;          public BankAccount(double ini){              this.balance = ini;          }                    protected Object clone(){              BankAccount bankAccount = null;              try {                  bankAccount = (BankAccount)super.clone();              } catch (CloneNotSupportedException e) {                  e.printStackTrace();              }              return bankAccount;          }                    public void add(double give){              this.balance += give;          }                    public void redu(double give){              this.balance -= give;          }                    public double getBalance() {              return balance;          }          public void setBalance(double balance) {              this.balance = balance;          }      }  

  程序入口 TestClone.java 如下：

    package clone;      public class TestClone {          public static void main(String[] args) {              BankAccount bc1 = new BankAccount(1000.0);              BankAccount bc2 = (BankAccount) bc1.clone();              bc1.add(25);              bc2.add(20);              System.out.println("用户 1 的帐户余额为：" + bc1.getBalance());              System.out.println("用户 2 的帐户余额为：" + bc2.getBalance());          }      }  

执行 TestClone.java，打印结果如下：
用户 1 的帐户余额为：1025.0
用户 2 的帐户余额为：1020.0
        这下用户 2 把钱存进了自己的帐户，而 Java 程序员也不用头疼了。皆大欢喜。

以上部分转自：http://blog.csdn.net/defonds/article/details/5114486

通过以上的例子说明了在java中如何进行对象的数据。 但代码例子中，对象BankAccount中的属性是double类型，即是基本数据类型（primitive）,这种情况下，可以直接

在重载的clone方法里面调用super.clone（）.进行引用的复制。

但是如果被克隆的对象的属性不是基本数据类型（primitive），而是字符串String呢？   --（我们知道在java中String属于特殊引用类型，不可变类型）

看如下例子：

import org.junit.Assert;    class User implements Cloneable {          String name;          int age;                @Override          public Object clone() throws CloneNotSupportedException {              return super.clone();          }      }          public class DeepClone{      public static void main(String[] a){          // user.          User user = new User();          user.name = "user";          user.age = 20;                    // copy          User copy = null;try {copy = (User) user.clone();} catch (CloneNotSupportedException e) {// TODO Auto-generated catch blocke.printStackTrace();}           //copy 和user不相等 System.out.println(copy==user);         // age因为是primitive，所以copy和原型是相等且独立的。  System.out.println("user.age = "+user.age+", copy.age = "+copy.age);                copy.age = 30;          // 改变copy不影响原型。          System.out.println("user.age = "+user.age+", copy.age = "+copy.age);                  // name因为是引用类型，所以copy和原型的引用是同一的。         System.out.println(copy.name == user.name);                // String为不可变类。没有办法可以通过对copy.name的字符串的操作改变这个字符串。          // 改变引用新的对象不会影响原型。          copy.name = "newname";                  System.out.println("user.name = "+user.name+", copy.name = "+copy.name);            }  }  

结果为：

falseuser.age = 20, copy.age = 20user.age = 20, copy.age = 30trueuser.name = user, copy.name = newname

user和copy是两个引用，达到了复制的目的，但是对于内部属性name，他们的引用确是同一个，之所以没办法通过对copy.name的字符串操作改变这个字符串，是因为String类型的特殊性。String类型的引用在栈上，数值在堆里。更改赋值 ，String重新申请一块内存。

可见，在考虑clone时，primitive和不可变对象类型是可以同等对待

那么，如果被克隆对象的属性是其他引用类型呢?

接着看例子：

class UnCloneA {      private int i;      public UnCloneA(int ii) { i = ii; }      public void doubleValue() { i *= 2; }      public String toString() {          return Integer.toString(i);      }  } class CloneB implements Cloneable{      public int aInt;      public UnCloneA unCA = new UnCloneA(111);          //重写clone()方法    public Object clone(){          CloneB o = null;          try{              o = (CloneB)super.clone();          }catch(CloneNotSupportedException e){              e.printStackTrace();          }          return o;      }  }  public class cloneMain {public static void main(String[] a){          CloneB b1 = new CloneB();          b1.aInt = 11;          System.out.println("before clone,b1.aInt = "+ b1.aInt);          System.out.println("before clone,b1.unCA = "+ b1.unCA);                            CloneB b2 = (CloneB)b1.clone();          b2.aInt = 22;          b2.unCA.doubleValue();  //对克隆后对象的对象属性进行值加倍操作        System.out.println("=================================");          System.out.println("after clone,b1.aInt = "+ b1.aInt);          System.out.println("after clone,b1.unCA = "+ b1.unCA);          System.out.println("=================================");          System.out.println("after clone,b2.aInt = "+ b2.aInt);          System.out.println("after clone,b2.unCA = "+ b2.unCA);      }  }

结果为：

before clone,b1.aInt = 11before clone,b1.unCA = 111=================================after clone,b1.aInt = 11after clone,b1.unCA = 222=================================after clone,b2.aInt = 22after clone,b2.unCA = 222

输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，int类型是真正的被clone了，因为改变了b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA。

很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！

从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。【请比较为什么String类型的克隆指向的不是同一个内存】

这种克隆被称为影子克隆。

要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。【请忽略上一个例子中的DeepClone类名，这个类名是不准确的】

怎么进行深度clone？


把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();

程序如下：

package clone.ext;class UnCloneA implements Cloneable{    private int i;    public UnCloneA(int ii) { i = ii; }    public void doubleValue() { i *= 2; }    public String toString() {        return Integer.toString(i);    }    public Object clone(){        UnCloneA o = null;        try{            o = (UnCloneA)super.clone();        }catch(CloneNotSupportedException e){            e.printStackTrace();        }        return o;    }}class CloneB implements Cloneable{    public int aInt;    public UnCloneA unCA = new UnCloneA(111);    public Object clone(){        CloneB o = null;        try{            o = (CloneB)super.clone();        }catch(CloneNotSupportedException e){            e.printStackTrace();        }        o.unCA = (UnCloneA)unCA.clone();        return o;    }}public class CloneMain {    public static void main(String[] a){        CloneB b1 = new CloneB();        b1.aInt = 11;        System.out.println("before clone,b1.aInt = "+ b1.aInt);        System.out.println("before clone,b1.unCA = "+ b1.unCA);                       CloneB b2 = (CloneB)b1.clone();        b2.aInt = 22;        b2.unCA.doubleValue();        System.out.println("=================================");        System.out.println("after clone,b1.aInt = "+ b1.aInt);        System.out.println("after clone,b1.unCA = "+ b1.unCA);        System.out.println("=================================");        System.out.println("after clone,b2.aInt = "+ b2.aInt);        System.out.println("after clone,b2.unCA = "+ b2.unCA);    }}/** RUN RESULT:before clone,b1.aInt = 11before clone,b1.unCA = 111=================================after clone,b1.aInt = 11after clone,b1.unCA = 111=================================after clone,b2.aInt = 22after clone,b2.unCA = 222*/

可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。

知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个final类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是SringBuffer对象，而且变量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone();

还要知道的是除了基本数据类型能自动实现深度clone以外，String对象是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。

通过以上我们可以看出在某些情况下，我们可以利用clone方法来实现对象只见的复制，但对于比较复杂的对象（比如对象中包含其他对象，其他对象又包含别的对象.....）这样我们必须进行层层深度clone，每个对象需要实现cloneable接口，比较麻烦

以上转自：http://liran-email.iteye.com/blog/550249