云南网站定制开发什么网站可以发布广告
什么是java中的浅克隆和深克隆?
浅克隆:克隆对象中的变量与之前对象的值相同,并且对象中的引用类型变量仍然指向原来对象引用类型变量的地址.
深克隆:克隆对象中的变量与之前对象的值相同，并且对象中的引用类型变量指向了新的对象的引用变量的地址.
要想实现克隆，只需定义的类声明下cloneable这个标记性接口,并且衍生重写Object类中就有的clone()方法即可.
为什么类要首先声明cloneable标记接口，然后重写clone()方法？因为不声明cloneable调用clone()方法会抛出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.
*/
private native Object internalClone();
在上一节中讲了java中Serializable与Parcelable的使用序列化与反序列化的问题。事实上利用对象输出流对对象进行序列化,利用对象的输入流对对象进行反序列化也可以实现克隆,如果对象中依赖的其他对象的引用也实现了序列化(即引用类实现了serializable标记接口)就实现了深度克隆,否则实现了浅克隆.
实现了Serializable接口的Company
public class Company implements Serializable {//Serializable接口是空的,没有声明的方法及常量
private static final long serialVersionUID = 1L; //序列化标识
private String name;
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Company(String name, String address) {
this.name = name;
this.address = address;
}
@Override
public String toString() {
return "company name is:"+name+",address is:"+address;
}
}
获得实现了Serializable接口的克隆实例调用方法。
private T getCopyObj(T t) {
ByteArrayOutputStream byteArrayOutputStream = null;
ObjectOutputStream objectOutputStream = null;
ByteArrayInputStream byteArrayInputStream = null;
ObjectInputStream objectInputStream = null;
try {
byteArrayOutputStream = new ByteArrayOutputStream();
objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(t);//序列化对象
objectOutputStream.flush();
byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
objectInputStream = new ObjectInputStream(byteArrayInputStream);
T t1 = (T) objectInputStream.readObject();
return t1;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (byteArrayOutputStream != null) {
try {
byteArrayOutputStream.close();
byteArrayOutputStream = null;
} catch (IOException e) {
e.printStackTrace();
}
}
if (objectOutputStream != null) {
try {
objectOutputStream.close();
objectOutputStream = null;
} catch (IOException e) {
e.printStackTrace();
}
}
if (byteArrayInputStream != null) {
try {
byteArrayInputStream.close();
byteArrayInputStream = null;
} catch (IOException e) {
e.printStackTrace();
}
}
if (objectInputStream != null) {
try {
objectInputStream.close();
objectInputStream = null;
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
}
测试通过的testCase，说明通过Serializable的反序列化创建的是一个新的对象,不再是之前的对象了。
@Test
public void test() throws CloneNotSupportedException {
Company company=new Company("百度","上地十街");
Company copyCompany=getCopyObj(company);
copyCompany.setName("腾讯");
Assert.assertEquals(false,company==copyCompany);
Assert.assertEquals(true,company.getName().equals("百度"));
Assert.assertEquals(true,copyCompany.getName().equals("腾讯"));
}
实现了Clonable克隆的例子
public class People implements Cloneable {
private String name;
private int age;
public People(String name, int age) {
this.name = name;
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
验证通过的case,表明了克隆出来的对象与原来的对象地址不一样,是一个新的对象,所以克隆对象中的name和age是新的.
@Test
public void test() throws CloneNotSupportedException {
People people = new People("storm", 30);
People clonePeople = (People) people.clone();
clonePeople.setName("stormClone");
clonePeople.setAge(29);
Assert.assertFalse(people == clonePeople);
System.out.println("people name=" + people.getName());//people name=storm
System.out.println("people age=" + people.getAge());//people age=30
System.out.println("clonePeople name=" + clonePeople.getName());//clonePeople name=stormClone
System.out.println("clonePeople age=" + clonePeople.getAge());//clonePeople age=29
}
使用cloneable实现浅克隆
public class Animal {
private String animalName;
public Animal(String animalName) {
this.animalName = animalName;
}
public String getAnimalName() {
return animalName;
}
public void setAnimalName(String animalName) {
this.animalName = animalName;
}
}
public class People implements Cloneable {
private String name;
private int age;
private Animal animal;//克隆对象中的引用型变量
public People(String name, int age,Animal animal) {
this.name = name;
this.age = age;
this.animal=animal;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Animal getAnimal() {
return animal;
}
public void setAnimal(Animal animal) {
this.animal = animal;
}
}
验证通过的case，表明了克隆对象的引用型变量animal并未发生改变,也即使内存中的地址并未发生改变,所以对其name的更改会影响原对象与克隆对象的值.
@Test
public void test() throws CloneNotSupportedException {
Animal animal=new Animal("cat");
People people = new People("storm", 30,animal);
People clonePeople = (People) people.clone();
animal.setAnimalName("dog");
Assert.assertFalse(people == clonePeople);
Assert.assertTrue(people.getAnimal()==clonePeople.getAnimal());
Assert.assertTrue(people.getAnimal().getAnimalName().equals("dog"));
Assert.assertTrue(clonePeople.getAnimal().getAnimalName().equals("dog"));
}
使用cloneable实现深克隆(实现很简单只需要引用类型变量实现cloneable接口即可)，相比浅克隆,只需做如下修改.
public class Animal implements Cloneable{
private String animalName;
public Animal(String animalName) {
this.animalName = animalName;
}
public String getAnimalName() {
return animalName;
}
public void setAnimalName(String animalName) {
this.animalName = animalName;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
验证通过的case，表明了克隆对象的引用型变量animal发生改变,也即内存中的地址发生改变,所以对其name的更改不会影响克隆对象的值.同时说明了进行深克隆会把所有的引用类型都实现cloneable接口,如果克隆对象中的引用类型变量比较多的话,这牵涉的工作量就会比较大了,这时我们考虑使用上面实现Serializable实现克隆的方式,缺点是反复进行IO操作，内存开销大.
@Test
public void test() throws CloneNotSupportedException {
Animal animal=new Animal("cat");
People people = new People("storm", 30,animal);
People clonePeople = (People) people.clone();
Animal cloneAnimal=(Animal) animal.clone();
clonePeople.setAnimal(cloneAnimal);
animal.setAnimalName("dog");
Assert.assertFalse(people == clonePeople);
Assert.assertFalse(people.getAnimal()==clonePeople.getAnimal());
Assert.assertTrue(people.getAnimal().getAnimalName().equals("dog"));
Assert.assertTrue(clonePeople.getAnimal().getAnimalName().equals("cat"));
}