Java克隆clone的浅复制与深复制

一、需求

1.问题引入：

假设在你的应用中想修改某个对象的属性或值，比如：我想修改某个ArrayList 集合对象list存有的元素，但我又不想影响原来的集合对象list，那么该怎么做呢？

或许你会想到直接这样 ArrayList list2 = list;  不就行了吗？呵呵，其实这样不是拷贝，这样的话list2 就完全等于list，操作list2即是操作list。

换换言之，在你执行这个操作后仍然只有一个对象，你只是多加了一个该list对象的一个引用。那么该如何解决这个问题呢？

2.解决方案：

使用所有类的父类Object 的clone()方法。

3.测试用例：

package org.xjh.test;import java.util.ArrayList;/** * ArrayList的clone方法测试 * @author xjh * */public class CloneTest {public static void main(String[] args) {ArrayList list = new ArrayList();list.add("123");list.add(1);list.add(100.0);System.out.println("初始list集合中的所有元素：" + list);ArrayList list2 = list;list2.remove(0);System.out.println("移除list2集合第一个元素之后，list集合的所有元素：" +list);ArrayList list3 = (ArrayList) list.clone();list3.remove(0);System.out.println("移除list3集合第一个元素之后，list集合的所有元素：" + list);}}

4.测试结果：

初始list集合中的所有元素：[123, 1, 100.0]
移除list2集合第一个元素之后，list集合的所有元素：[1, 100.0]
移除list3集合第一个元素之后，list集合的所有元素：[1, 100.0]

二、自定义可克隆的类（浅复制）

1.定义

浅拷贝（浅复制、浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

2.实现步骤：
　　1).在自定义类中覆盖Object类的clone()方法，并声明为public（Object类中的clone()方法是protected的，在子类重写的时候，可以扩大访问修饰符的范围）。
　　2).在自定义类的clone()方法中，调用super.clone()。
　　因为在运行时刻，Object类中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
　　3).在派生类中实现Cloneable接口。Cloneable接口中没有任何方法，只是作一种声明，表示该类具有复制的作用。

2.测试用例：

package org.xjh.test;import java.util.ArrayList;/** * 浅复制测试 * @author xjh * */public class CloneTest {public static void main(String[] args) throws CloneNotSupportedException {Student s1 = new Student("张三", 12);Student s2 = (Student) s1.clone();Student s3 = s1;System.out.println("s1的初始age的值="+s1.getAge());s2.setAge(20);System.out.println("修改s2的age值="+s2.getAge());System.out.println("修改s2的age值后，s1的age的值="+s1.getAge());s3.setAge(30);System.out.println("修改s3的age值="+s3.getAge());System.out.println("修改s2的age值后，s1的age的值="+s1.getAge());}}/** * 实现Cloneable接口并且覆写Object的clone方法的Student类 * @author xjh * */class Student implements Cloneable{    private String name;    private int age;        public Student() {super();}public Student(String name, int age) {super();this.name = name;this.age = age;}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;    }    /**     * 覆写Object类的clone方法，注意此处要把protected改为public,不然没法调用     */    @Override    public Object clone() throws CloneNotSupportedException    {    return super.clone();    }}

3.测试结果：

s1的初始age的值=12
修改s2的age值=20
修改s2的age值后，s1的age的值=12
修改s3的age值=30
修改s2的age值后，s1的age的值=30

三、自定义可复制的类（深复制）

1.定义

深拷贝（深复制、深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

2.实现步骤
        前提假设，A类中定义了一个属性，这个属性是另外一个类B的引用对象b。

　　1).在自定义类中覆盖Object类的clone()方法，并声明为public（Object类中的clone()方法是protected的，在子类重写的时候，可以扩大访问修饰符的范围）。
　　2).在自定义类的clone()方法中，调用super.clone()。
　　因为在运行时刻，Object类中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
　　3).在派生类中实现Cloneable接口。Cloneable接口中没有任何方法，只是作一种声明，表示该类具有复制的作用。

        4).在A类的clone方法中调用B类引用对象b的clone方法，并且让b重新指向b.clone的对象

3. 测试用例

package org.xjh.test;/** * 深复制测试 * @author xjh * */public class CloneTest2{    public static void main(String[] args) throws Exception    {        Teacher teacher = new Teacher();        teacher.setName("Teacher Zhang");        teacher.setAge(40);        Student2 student1 = new Student2();        student1.setName("ZhangSan");        student1.setAge(20);        student1.setTeacher(teacher);        Student2 student2 = (Student2) student1.clone();        System.out.println("拷贝得到的信息");        System.out.println(student2.getName());        System.out.println(student2.getAge());        System.out.println(student2.getTeacher().getName());        System.out.println(student2.getTeacher().getAge());        System.out.println("-------------");        // 修改老师的信息        teacher.setName("Teacher Zhang has changed");        System.out.println(student1.getTeacher().getName());        System.out.println(student2.getTeacher().getName());        // 两个引用student1和student2指向不同的两个对象        // 但是两个引用student1和student2中的两个teacher引用指向的是同一个对象        // 所以说明是浅拷贝        // 改为深复制之后，对teacher对象的修改只能影响第一个对象    }}class Teacher implements Cloneable{    private String name;    private int age;    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;    }    @Override    public Object clone() throws CloneNotSupportedException    {        return super.clone();    }}class Student2 implements Cloneable{    private String name;    private int age;    private Teacher teacher;    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 Teacher getTeacher()    {        return teacher;    }    public void setTeacher(Teacher teacher)    {        this.teacher = teacher;    }    @Override    public Object clone() throws CloneNotSupportedException    {        // 浅复制时：        // Object object = super.clone();        // return object;        // 改为深复制：        Student2 student = (Student2) super.clone();        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来        student.setTeacher((Teacher) student.getTeacher().clone());                //当然，也可以这样做，效果与上面的一样        //this.teacher = (Teacher) student.getTeacher().clone();                return student;    }}

3.测试结果：

拷贝得到的信息
ZhangSan
20
Teacher Zhang
40
-------------
Teacher Zhang
Teacher Zhang has changed

四、应用场景

那么，什么时候需要进行对象的克隆呢，一般需要满足以下条件：
　　1. 克隆对象与原对象不是同一个对象。即对任何的对象x：
　　x.clone() != x
　　2.克隆对象与原对象的类型一样。即对任何的对象x：
　　x.clone().getClass() == x.getClass()
　　3.如果对象x的equals()方法定义恰当，那么下式应该成立：
　　x.clone().equals(x)
　　因为一个定义良好的equals()方法就应该是用来比较内容是否相等的。