java cloneable 用途_java中cloneable的使用「建议收藏」

什么是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”));

}