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 block
e.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);
}
}
结果为:
false
user.age = 20, copy.age = 20
user.age = 20, copy.age = 30
true
user.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 = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 222
=================================
after clone,b2.aInt = 22
after 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 = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after 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