首先需要明白,浅拷贝和深拷贝都是针对一个已有对象的操作。那先来看看浅拷贝和深拷贝的概念。
在 Java 中,除了基本数据类型(元类型)之外,还存在 类的实例对象 这个引用数据类型。而一般使用 『 = 』号做赋值操作的时候。对于基本数据类型,实际上是拷贝的它的值,但是对于对象而言,其实赋值的只是这个对象的引用,将原对象的引用传递过去,他们实际上还是指向的同一个对象。
而浅拷贝和深拷贝就是在这个基础之上做的区分,如果在拷贝这个对象的时候,只对基本数据类型进行了拷贝,而对引用数据类型只是进行了引用的传递,而没有真实的创建一个新的对象,则认为是浅拷贝。反之,在对引用数据类型进行拷贝的时候,创建了一个新的对象,并且复制其内的成员变量,则认为是深拷贝。
接下来我们通过例子来分析
Java 中的 clone()方法
public class ParentBean implements Cloneable {
private ChildBean child;
public ParentBean(ChildBean child) {
this.child = child;
}
public ChildBean getChild() {
return child;
}
public void setChild(ChildBean child) {
this.child = child;
}
@TargetApi(Build.VERSION_CODES.N)
@Override
public ParentBean clone() {
try {
return (ParentBean) super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
}
public class ChildBean {
private String name;
public ChildBean(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
运行以下调试代码
ParentBean p1 = new ParentBean(new ChildBean("child"));
ParentBean p2;
p2 = p1.clone();
p1.getChild().setName("child change");
Log.i("msg", "p1 equals p2: " + p1.equals(p2));
Log.i("msg", "p1 child HashCode: " + p1.getChild().hashCode());
Log.i("msg", "p2 child HashCode: " + p2.getChild().hashCode());
Log.i("msg", "b2: " + p2.getChild().getName());
输出结果
I/msg: p1 equals p2: false
I/msg: p1 child HashCode: 142701218
I/msg: p2 child HashCode: 142701218
I/msg: b2: child change
从p1 equals p2: false
看似p2
深拷贝一个新的p1
对象,但从里面对象child
的地址可以看到,还是仅仅做了传值的操作,当p1
中的值做改变的时候,p2
的child
也发生了变化,所以这还是一个浅拷贝。
那怎么才能实现深拷贝呢,其实要对每一个自定义的对象都要实现Cloneable
接口,并重写方法clone()
,比如上面中的例子,需要ChlidBean
也同样实现Cloneable
,并且在ParentBean
的clone()
方法中对child
重新赋值。如下:
public class ChildBean implements Cloneable {
private String name;
public ChildBean(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@TargetApi(Build.VERSION_CODES.N)
@Override
public ChildBean clone() {
try {
return (ChildBean) super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
}
ParentBean:
@TargetApi(Build.VERSION_CODES.N)
@Override
public ParentBean clone() {
try {
ParentBean parent = (ParentBean) super.clone();
parent.setChild(this.getChild().clone());
return parent;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
然后重写运行下调试代码,输出结果如下:
I/msg: p1 equals p2: false
I/msg: p1 child HashCode: 142701218
I/msg: p2 child HashCode: 190274355
I/msg: b2: child
p1 child
和p2 child
的HashCode
值不一样,所指向的地址也发生了变化,当p1
中的值做改变的时候,p2
的child
并没有发生变化。故这样就完成了一次深拷贝。
实则浅拷贝和深拷贝只是相对的,如果一个对象内部只有基本数据类型,那用 clone()
方法获取到的就是这个对象的深拷贝,而如果其内部还有引用数据类型,那用clone()
方法就是一次浅拷贝的操作。
扩展阅读
如果我们查看java源码, 可以发现, 我们调用的clone()
方法是Object
对象的. 而不是Cloneable
接口的. 那么我们为什么要实现Cloneable
接口呢? 不实现Cloneable
接口可否调用Object
的clone()
方法呢?
我们先来看下Cloneable
接口的源码:
public interface Cloneable {
}
发现其中并没有任何方法. 幸运的是Java源码的java doc注释足够清晰:
/**
* A class implements the <code>Cloneable</code> interface to
* indicate to the {@link java.lang.Object#clone()} method that it
* is legal for that method to make a
* field-for-field copy of instances of that class.
* <p>
* Invoking Object's clone method on an instance that does not implement the
* <code>Cloneable</code> interface results in the exception
* <code>CloneNotSupportedException</code> being thrown.
* <p>
* By convention, classes that implement this interface should override
* <tt>Object.clone</tt> (which is protected) with a public method.
* See {@link java.lang.Object#clone()} for details on overriding this
* method.
* <p>
* Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
* Therefore, it is not possible to clone an object merely by virtue of the
* fact that it implements this interface. Even if the clone method is invoked
* reflectively, there is no guarantee that it will succeed.
*/
大体我们可以理解几点:
Cloneable
可以看着是一个标识, 实现了改接口的类才能合法地调用其从Object
类中继承而来的clone()
方法.
如果没有实现Cloneable
接口而调用clone()
方法, 会触发CloneNotSupportedException
异常.
实现Cloneable
接口的类应当重写Object
的clone()
方法.
参考
https://my.oschina.net/jackieyeah/blog/206391
https://segmentfault.com/a/1190000010648514
https://www.jianshu.com/p/ca5abfca2c6d