一、Cloneable是啥
Cloneable是java的一个接口,接口里并没有需要强制实现的方法,因此这是一个标记性接口,如果要使用clone方法,就必须实现Cloneable接口,否则会抛出CloneNotSupportedException异常。
// BEGIN Android-changed: Use native local helper for clone()
// Checks whether cloning is allowed before calling native local helper.
// protected native Object clone() throws CloneNotSupportedException;
protected Object clone() throws CloneNotSupportedException {
if (!(this instanceof Cloneable)) {
throw new CloneNotSupportedException(
"Class " + getClass().getName() + doesn't implement Cloneable");
}
return internalClone();
}
/*
* Native helper method for cloning.
*/
@FastNative
private native Object internalClone();
// END Android-changed: Use native local helper for clone()
通过源码可知internalClone方法体是在native层去实现的,并且在调用clone方法时会去校验是否实现了Cloneable接口
二、深拷贝和浅拷贝是如何体现的?
深 浅拷贝 的区别个人觉得是引用地址的传递还是真正的对象拷贝,下面通过代码来解释说明。
public class Teacher implements Cloneable{
public String name;
public int age;
public Student student;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Student {
public String name;
public int age;
}
Teacher teacher = new Teacher();
teacher.name="老师";
teacher.age = 100;
Student student = new Student();
student.name="学生";
student.age=90;
teacher.student = student;
try {
Teacher cloneTeacher = (Teacher) teacher.clone();
//两者hash值不同
Log.e("teacher",teacher.hashCode()+" "+cloneTeacher.hashCode());
//两者hash值相同
Log.e("teacher",teacher.student.hashCode()+" "+cloneTeacher.student.hashCode());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
通过打印日志发现,通过clone方法,能完全复制一个新对象,可以通过gson转换成json数据查看两者的属性值是一样的,但是你会发现teacher跟cloneTeacher虽然是不同的对象,但是他们的student却是同一个对象,因为两者hash值是一样的,你也可以通过修改cloneTeacher里student的name值,然后去打印查看teacher里的student的name值是否也随之改变。这其实就是浅拷贝,可以理解为student对象没有重新创建,只是引用地址还是指向原有的,克隆后的teacher对象共享同一个student。
接下来我们尝试修改上面的代码
public class Teacher implements Cloneable{
public String name;
public int age;
public Student student;
@Override
protected Object clone() throws CloneNotSupportedException {
Teacher teacher = (Teacher) super.clone();
//这里对student进行深度克隆
teacher.student = (Student) student.clone();
return teacher;
}
}
public class Student implements Cloneable{
public String name;
public int age;
@Override
protected Object clone() throws CloneNotSupportedException {
//因为teacher对student进行了clone方法的调用,所以这里也要重写该方法,并实现Cloneable接口
return super.clone();
}
}
代码修改完毕后再次进行上面的log验证
//两者hash值不同
Log.e("teacher",teacher.hashCode()+" "+cloneTeacher.hashCode());
//两者hash值不同
Log.e("teacher",teacher.student.hashCode()+" "+cloneTeacher.student.hashCode());
因此可以判断此时两者的student对象不是指向同一个了,这就是深拷贝。
总结:如果对克隆对象只是取值操作的话,深浅拷贝没有区别,但是一旦涉及对克隆对象属性的修改这种浅拷贝方式就很危险,影响了其他业务对原始数据的使用。因此日常开发中要注意,尽量考虑用 深拷贝 方法,采用这种套娃的方式,在clone方法里,依次对引用类型进行手动clone并赋值。
深拷贝
深拷贝相对于浅拷贝而言,会对所有数据类型都进行拷贝一份,包括这个对象所包含的内部对象。java 中上实现深拷贝的方式有两种:
对浅拷贝进行加强,对象中引用属性进行 clone 操作;
通过序列化;
借助三方工具类;
序列化
User 类实现 Serializable 接口,对堆区中的实例进行读写,从而实现对实例的全部拷贝。
public class User implements Serializable, Cloneable {
private String name;
private Integer age;
private Animal animal;
get...set...
@Override
protected User clone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
oos.flush();
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
return (User) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
return null;
}
}
}
借助三方工具类
@Override
protected User clone() {
String s = JSON.toJSONString(this);
return JSON.parseObject(s, User.class);
}