看Android源码学习之Java的clone()：深复制与浅复制

在看AMS时遇到
android/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

 final ProcessRecord getProcessRecordLocked(String processName, int uid, boolean keepIfLarge) {
    if (uid == SYSTEM_UID) {
        // The system gets to run in any process.  If there are multiple
        // processes with the same uid, just pick the first (this
        // should never happen).
        SparseArray<ProcessRecord> procs = mProcessNames.getMap().get(processName);
        if (procs == null) return null;
              final int procCount = procs.size();
              for (int i = 0; i < procCount; i++) {
                  final int procUid = procs.keyAt(i);
                  if (UserHandle.isApp(procUid) || !UserHandle.isSameUser(procUid, uid)) {
                      // Don't use an app process or different user process for system component.
                      continue;
                  }
                  return procs.valueAt(i);
              }
     ......

这个procs 是个什么对象，查看源码：
android/frameworks/base/core/java/android/util/SparseArray.java

public class SparseArray<E> implements Cloneable {
    ......
      @Override
      @SuppressWarnings("unchecked")
      public SparseArray<E> clone() {
          SparseArray<E> clone = null;
          try {
              clone = (SparseArray<E>) super.clone();
              clone.mKeys = mKeys.clone();
              clone.mValues = mValues.clone();
          } catch (CloneNotSupportedException cnse) {
              /* ignore */
          }
          return clone;
      }

SparseArray< E >是一个实现了Cloneable 接口的类，Java中要想自定义类的对象可以被复制，自定义类就必须实现Cloneable中的clone()方法

下面说一下如何实现clone()方法，Java的clone()分深复制与浅复制
先看下浅复制：

public class Student implements Cloneable {

    private String name;

    private int age;

    private Professor professor;

    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 Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", professor="
                + professor + "]";
    }

    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

}

其中，Professor类同样为自定义类：

public class Professor {

    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 String toString() {
        return "Professor [name=" + name + ", age=" + age + "]";
    }

}

当自定义类的字段的类型不是基本数据类型时，上面实现了clone()方法会导致问题，下面的测试代码：

public class ShadowCopy {

    public static void main(String[] args) {
        Professor p1 = new Professor();
        p1.setName("Professor Zhang");
        p1.setAge(30);

        Student s1 = new Student();
        s1.setName("xiao ming");
        s1.setAge(18);
        s1.setProfessor(p1);

        System.out.println(s1);

        try {
            Student s2 = (Student) s1.clone();
            Professor p2 = s2.getProfessor();
            p2.setName("Professor Li");
            p2.setAge(45);
            s2.setProfessor(p2);
            System.out.println("复制后的：s1 = " + s1);
            System.out.println("复制后的：s2 = " + s2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

}

运行结果:

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]
3 复制后的：s2 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]

学生s1的导师为30岁的Professor Zhang，恰好学生s2与学生s1同名同岁，但是s2的导师为45岁的Professor Li，于是我们顺理成章地复制复制s1并复制给s2，再修改下s2的导师的信息。可是，问题出现了，当我们修改了s2的导师后，s2的信息是对了，但是s1的导师信息也跟着修改了，这可不是我们期望的。

【问题分析】

程序实例1中的问题出在哪儿呢？我们已经对Student类实现了clone()方法，怎么还是出问题了呢？我们在看下面的代码：

public class ShadowCopy {

    public static void main(String[] args) {
        Professor p1 = new Professor();
        p1.setName("Professor Zhang");
        p1.setAge(30);

        Student s1 = new Student();
        s1.setName("xiao ming");
        s1.setAge(18);
        s1.setProfessor(p1);

        System.out.println(s1);

        try {
            Student s2 = (Student) s1.clone();
            s2.setName("xiao hong");
            s2.setAge(17);
            Professor p2 = s2.getProfessor();
            p2.setName("Professor Li");
            p2.setAge(45);
            s2.setProfessor(p2);
            System.out.println("复制后的：s1 = " + s1);
            System.out.println("复制后的：s2 = " + s2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

}

【运行结果】

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]
3 复制后的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]

这次，我们在clone后，又修改了s2的name和age，从结果可以看出，s1的name和age并没有因为s2的修改而改变。

结合程序实例1和程序实例2，我们发现Student的字段如果不是一个引用时，修改clone()得到对象的该字段(name, age)时并不会影响原来的对象，但是当字段为一个引用时，修改clone()得到对象的该字段(professor)时并会影响原来的对象。上面实现的clone()方法为浅复制（shadow copy）。

如果想要clone()得到的新对象的修改不会影响被复制的对象的字段时，我们就需要实现深复制（deep copy），代码修改如下：

public class Professor 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 String toString() {
        return "Professor [name=" + name + ", age=" + age + "]";
    }

    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

}

public class Student implements Cloneable {

    private String name;

    private int age;

    private Professor professor;

    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 Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", professor="
                + professor + "]";
    }

    public Object clone() throws CloneNotSupportedException{
        Student newStudent = (Student) super.clone();
        newStudent.professor = (Professor) professor.clone();
        return newStudent;
    }

}

再次运行【程序实例2】得到的结果为：

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
3 复制后的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]

可以看到：修改clone()得到的s2的任何字段都不会影响s1的字段，这也就是深复制的作用。