Java的clone()：深复制与浅复制

Java中要想自定义类的对象可以被复制，自定义类就必须实现Cloneable中的clone()方法，如下：

 1 public class Student implements Cloneable {
 2
 3     private String name;
 4
 5     private int age;
 6
 7     private Professor professor;
 8
 9     public String getName() {
10         return name;
11     }
12
13     public void setName(String name) {
14         this.name = name;
15     }
16
17     public int getAge() {
18         return age;
19     }
20
21     public void setAge(int age) {
22         this.age = age;
23     }
24
25     public Professor getProfessor() {
26         return professor;
27     }
28
29     public void setProfessor(Professor professor) {
30         this.professor = professor;
31     }
32
33     @Override
34     public String toString() {
35         return "Student [name=" + name + ", age=" + age + ", professor="
36                 + professor + "]";
37     }
38
39     public Object clone() throws CloneNotSupportedException{
40         return super.clone();
41     }
42
43 }

其中，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()方法会导致问题，不信看下面的代码：

【程序实例1】

 1 public class ShadowCopy {
 2
 3     public static void main(String[] args) {
 4         Professor p1 = new Professor();
 5         p1.setName("Professor Zhang");
 6         p1.setAge(30);
 7
 8         Student s1 = new Student();
 9         s1.setName("xiao ming");
10         s1.setAge(18);
11         s1.setProfessor(p1);
12
13         System.out.println(s1);
14
15         try {
16             Student s2 = (Student) s1.clone();
17             Professor p2 = s2.getProfessor();
18             p2.setName("Professor Li");
19             p2.setAge(45);
20             s2.setProfessor(p2);
21             System.out.println("复制后的：s1 = " + s1);
22             System.out.println("复制后的：s2 = " + s2);
23         } catch (CloneNotSupportedException e) {
24             e.printStackTrace();
25         }
26
27     }
28
29 }

【运行结果1】

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()方法，怎么还是出问题了呢？我们在看下面的代码：

【程序实例2】

 1 public class ShadowCopy {
 2
 3     public static void main(String[] args) {
 4         Professor p1 = new Professor();
 5         p1.setName("Professor Zhang");
 6         p1.setAge(30);
 7
 8         Student s1 = new Student();
 9         s1.setName("xiao ming");
10         s1.setAge(18);
11         s1.setProfessor(p1);
12
13         System.out.println(s1);
14
15         try {
16             Student s2 = (Student) s1.clone();
17             s2.setName("xiao hong");
18             s2.setAge(17);
19             Professor p2 = s2.getProfessor();
20             p2.setName("Professor Li");
21             p2.setAge(45);
22             s2.setProfessor(p2);
23             System.out.println("复制后的：s1 = " + s1);
24             System.out.println("复制后的：s2 = " + s2);
25         } catch (CloneNotSupportedException e) {
26             e.printStackTrace();
27         }
28
29     }
30
31 }

【运行结果】

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），代码修改如下：

 1 public class Professor implements Cloneable {
 2
 3     private String name;
 4
 5     private int age;
 6
 7     public String getName() {
 8         return name;
 9     }
10
11     public void setName(String name) {
12         this.name = name;
13     }
14
15     public int getAge() {
16         return age;
17     }
18
19     public void setAge(int age) {
20         this.age = age;
21     }
22
23     @Override
24     public String toString() {
25         return "Professor [name=" + name + ", age=" + age + "]";
26     }
27
28     public Object clone() throws CloneNotSupportedException{
29         return super.clone();
30     }
31
32 }

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的字段，这也就是深复制的作用。

原文地址：https://www.cnblogs.com/renjiaqi/p/10390991.html

时间： 2024-08-03 23:05:36

Java的clone()：深复制与浅复制的相关文章

Java中的clone()----深复制，浅复制

这篇文章主要介绍了Java中对象的深复制(深克隆)和浅复制(浅克隆) ,需要的朋友可以参考下 1．浅复制与深复制概念 ⑴浅复制(浅克隆) 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. ⑵深复制(深克隆) 被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量.那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象.换言之,深复制把要复制的对象所引用

java中的clone：深复制和浅复制

参考文章: java中的深复制和浅复制 : http://blog.csdn.net/naughty610/article/details/6598943 Java 深拷贝和浅拷贝: http://www.cnblogs.com/mengdd/archive/2013/02/20/2917971.html 

clone()方法、深复制和浅复制

clone方法 Java中没有明确提供指针的概念和用法,而实质上没个new语句返回的都是一个指针的引用,只不过在大部分情况下开发人员不需要关心如何去操作这个指针而已. 在实际编程中,经常会遇到从某个已有对象A创建出另一个与A具有相同状态的对象B,并且B的修改不会影响到A的情况,例如Prototype(原型)模式中,就需要clone一个对象实例. 仅仅通过简单的复制操作显然无法达到这个目的,而Java提供了一个简单有效的clone()方法来满足这个需求. Java中所有的类默认都继承自Object

Java对象的深复制和浅复制

浅复制与深复制概念 浅复制(浅克隆) :被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. 深复制(深克隆) :被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量.那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象.换言之,深复制把要复制的对象所引用的对象都复制了一遍. Java的clone()方法 (1)clone方法将对象复制了一份并返回给调

Java对象深复制、浅复制

我们在编码过程经常会碰到将一个对象传递给另一个对象,java中对于基本型变量采用的是值传递,而对于对象比如bean传递时采用的引用传递也就是地址传递,而很多时候对于对象传递我们也希望能够象值传递一样,使得传递之前和之后有不同的内存地址,在这种情况下我们一般采用以下两种情况. 浅复制与深复制概念 浅复制(浅克隆) :被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. 深复制(深克隆) :被复制对象

.NET中深复制与浅复制

概述: 在.NET里面,提供对象复制的功能,前提是实现ICloneable接口.ICloneable接口中有一个Clone方法, 可以在类中覆写实现自定义的拷贝方法.对象复制的实现方法有两种:深复制和浅复制. 深复制和浅复制: 浅复制,浅复制是指源对象与复制出来的对象共用一份实体,对其中任何一个对象的改动都会影响另外一个对象.相当于复制了指针. 深复制:指源对象与复制对象互相独立,为新对象重新分配了一段内存空间,并复制源对象的内容.其中任何一个对象的改动都不会对另外一个对象造成影响. 深浅复制与

iOS 集合的深复制与浅复制

概念 对象拷贝有两种方式:浅复制和深复制.顾名思义,浅复制,并不拷贝对象本身,仅仅是拷贝指向对象的指针:深复制是直接拷贝整个对象内存到另一块内存中. 一图以蔽之 再简单些说:浅复制就是指针拷贝:深复制就是内容拷贝. 集合的浅复制 (shallow copy) 集合的浅复制有非常多种方法.当你进行浅复制时,会向原始的集合发送retain消息,引用计数加1,同时指针被拷贝到新的集合. 现在让我们看一些浅复制的例子: NSArray *shallowCopyArray = [someArray cop

深复制与浅复制

概念 对象拷贝有两种方式:浅复制和深复制.顾名思义,浅复制,并不拷贝对象本身,仅仅是拷贝指向对象的指针:深复制是直接拷贝整个对象内存到另一块内存中. 一图以蔽之 再简单些说:浅复制就是指针拷贝:深复制就是内容拷贝. 集合的浅复制 (shallow copy) 集合的浅复制有非常多种方法.当你进行浅复制时,会向原始的集合发送retain消息,引用计数加1,同时指针被拷贝到新的集合. 现在让我们看一些浅复制的例子: NSArray *shallowCopyArray = [someArray cop

OC 中 的copy 功能 深复制 和 浅复制 的 区别

系统的类要是实现copy拷贝的功能,必须先签订拷贝NSCopying的协议,然后实现对应的方法 在.h文件中得@interface Boy : NSObject 的后面需要签订拷贝NSCopying的协议 例子: 在.h文件中 @interface Boy : NSObject<NSCopying> 1. Boy类使用copy的方法 例子: Boy *boy =[Boy boyWithName:@"zhangyangyang" hobby:@"wan"]

C++学习基础七——深复制与浅复制

一.深复制与浅复制基本知识 深复制和浅复制,又称为深拷贝和浅拷贝. 深复制和浅复制的区别如下图1所示: 图1 图1表示的是,定义一个类CDemo,包含int a和char *str两个成员变量, 当深复制时,A中的指针str与B中的指针str指向不同的地址,只是地址所指向的数据相同. 当浅复制时,A中的指针str与B中的指针str指向相同的地址. 1.浅复制:如果我们自己不实现复制构造函数,则C++会自动合成一个复制构造函数,又称为浅复制构造函数. 2.深复制:如果使用指针或者系统资源(如数据库