java中对象的深拷贝和浅拷贝

根据对象成员变量的拷贝程度（基本数据类型、引用类型），可将拷贝分为浅拷贝和深拷贝。

一、浅拷贝

package javaKeyTechnology;

class PerSon{
    private String name;
    private int age;
    PerSon(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){ //私有数据的更改器
        this.name = name;
    }

    public String getName(){ //私有数据的访问器
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }

    public String toString(){
        return "Person:["+this.hashCode()+" name:"+name+" age:"+age+"]";
    }

}
public class MyClone implements Cloneable{
    PerSon man;
    private int id;
    private String gender;

    public MyClone(String name,int age,String gender,int id){
        man = new PerSon(name,age);
        this.gender = gender;
        this.id = id;
    }
    public void setId(int id){
        this.id = id;
    }

    public int getId(){
        return id;
    }

    public void setGender(String gender){
        this.gender = gender;
    }

    public String getGender(){
        return gender;
    }
    public String toString(){
        return man.toString() + this.hashCode() + " gender:"+gender+" id:"+id;
    }

    //浅拷贝
    public MyClone clone(){
        try {
            return (MyClone)super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    public static void main(String[] args){
        MyClone student1 = new MyClone("LiLi",16,"felman",123456);
        MyClone student2 = student1.clone();
        MyClone student3 = student1;
        student2.man.setAge(20);//改变student的引用变量的内容
        student2.man.setName("Jason");
        student2.setId(888888);//改变student的基本类型变量的内容
        student2.setGender("man");
        System.out.println("浅拷贝");
        System.out.println("student1:        " + student1.toString());
        System.out.println("student1.clone   " + student2.toString());
        System.out.println("对象拷贝");
        System.out.println("student1.copy:   " + student1.toString());
    }
}

可见，对于浅拷贝：

1.创建了新对象，和原对象的hashcode不同；

2.成员变量中的基本数据类型是是拷贝其值，新对象和原对象中任一对象的基本数据类型发生改变，对另一对象不产生影响。所以原对象的id没有改变。

3.成员变量中的不可变对象的引用类型（如String），虽然是拷贝其地址，由于其引用的对象不可变，改变新对象和原对象任一的该变量（引用），只是让它引用了新的不可变对象，另外一个对象的该变量所引用的对象不变。所以原对象的gender没有改变。

4.成员变量中的可变对象的引用类型是是拷贝地址。新对象和原对象中该变量指向同一对象，所以person的hashCode相同；任一对象的该引用的对象内容发生改变，对另一对象产生影响，所以原对象的person内容也改变了。

5.Object.clone()是浅拷贝，如果在实现了Cloneable接口后只调用Object.clone()，自然也只能是浅拷贝。

对于浅拷贝和对象拷贝的区别：

1.浅拷贝创建了新对象，两对象地址不同。

2.对象拷贝没有创建新对象，两个变量指向的是同一个对象，同一个地址。

二、深拷贝

package javaKeyTechnology;

class PerSon implements Cloneable{
    private String name;
    private int age;
    PerSon(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){ //私有数据的更改器
        this.name = name;
    }

    public String getName(){ //私有数据的访问器
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }

    public String toString(){
        return "Person:["+this.hashCode()+" name:"+name+" age:"+age+"]";
    }

    public PerSon clone(){
        try {
            return (PerSon)super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

}
public class MyClone implements Cloneable{
    PerSon man;
    private int id;
    private String gender;

    public MyClone(String name,int age,String gender,int id){
        man = new PerSon(name,age);
        this.gender = gender;
        this.id = id;
    }
    public void setId(int id){
        this.id = id;
    }

    public int getId(){
        return id;
    }

    public void setGender(String gender){
        this.gender = gender;
    }

    public String getGender(){
        return gender;
    }
    public String toString(){
        return man.toString() + this.hashCode() + " gender:"+gender+" id:"+id;
    }

    //深拷贝
    public MyClone clone(){
        try {
            MyClone tmp = (MyClone)super.clone();
            tmp.man = man.clone(); //把现在对象的man克隆
            return tmp;
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    public static void main(String[] args){
        MyClone student1 = new MyClone("LiLi",16,"felman",123456);
        MyClone student2 = student1.clone();
        student2.man.setAge(20);//改变student的引用变量的内容
        student2.man.setName("Jason");
        student2.setId(888888);//改变student的基本类型变量的内容
        student2.setGender("man");
        System.out.println("深拷贝");
        System.out.println("student1:        " + student1.toString());
        System.out.println("student1.clone   " + student2.toString());

    }
}

原对象和拷贝后创建的新对象中任一对象的任意成员变量（基本数据类型、不可变对象的引用、可变对象的引用）发生改变，都不影响另一个对象的成员变量。

深拷贝比浅拷贝多做的工作是：让新对象的引用变量 = 该引用所指对象的深拷贝

如果对象有多层对象（成员变量是引用），每层对象所属的类都要实现Cloneable接口并重写clone()。如果类的超类是Object，直接重写clone()。

原文地址：https://www.cnblogs.com/leechee9/p/11982787.html