java 深拷贝工具类多层对象

转载

索姆拉 2024-12-02 11:44:00

文章标签 java 深拷贝工具类多层对象引用类型浅拷贝基础数据类型 文章分类 Java 后端开发

Cloneable接口

cloneable其实就是一个标记接口，只有实现这个接口后，然后在类中重写Object中的clone方法，然后通过类调用clone方法才能克隆成功，如果不实现这个接口，则会抛出CloneNotSupportedException(克隆不被支持)异常。Object中clone方法：

java 深拷贝工具类多层对象_基础数据类型

native修饰的方法都是空的方法，但是这些方法都是有实现体的（这里也就间接说明了native关键字不能与abstract同时使用。因为abstract修饰的方法与java的接口中的方法类似，他显式的说明了修饰的方法，在当前是没有实现体的，abstract的方法的实现体都由子类重写），只不过native方法调用的实现体，都是非java代码编写的（例如：调用的是在jvm中编写的C的接口），每一个native方法在jvm中都有一个同名的实现体，native方法在逻辑上的判断都是由实现体实现的，另外这种native修饰的方法对返回类型，异常控制等都没有约束。由此可见，这里判断是否实现cloneable接口，是在调用jvm中的实现体时进行判断的。

介绍

开发过程中，有时会遇到把现有的一个对象的所有成员属性拷贝给另一个对象的需求。比如说对象 A 和对象 B，二者都是 ClassC 的对象，具有成员变量 a 和 b，现在对对象 A 进行拷贝赋值给 B，也就是 B.a = A.a; B.b = A.b;

这时再去改变 B 的属性 a 或者 b 时，可能会遇到问题：假设 a 是基础数据类型，b 是引用类型。
当改变 B.a 的值时，没有问题；
当改变 B.b 的值时，同时也会改变 A.b 的值，因为其实上面的例子中只是把 A.b 赋值给了 B.b，因为是 b 引用类型的，所以它们是指向同一个地址的。这可能就会给我们使用埋下隐患。

Java 中的数据类型分为基本数据类型和引用数据类型。对于这两种数据类型，在进行赋值操作、用作方法参数或返回值时，会有值传递和引用（地址）传递的差别。

拷贝分类

上面的问题，其实就是因为对拷贝的不熟悉导致的。

根据对对象属性的拷贝程度（基本数据类和引用类型），会分为两种：

浅拷贝（Shallow Copy）
深拷贝（Deep Copy）

浅拷贝

介绍：
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。

浅拷贝特点：

1、对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。

2、对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。

结构图：

java 深拷贝工具类多层对象_引用类型_02

代码实现：

Subject类，Student类的一个引用类型属性的类

public class Subject {

    private String name;

    public Subject(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Subject{" +
                "name='" + name + '\'' +
                '}';
    }
}

Student类

public class Student implements Cloneable{

    // 引用类型
    private Subject subject;

    // 基础数据类型
    private String name;

    // 基础数据类型
    private int age;

    public Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.subject = subject;
    }

    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 "Student{" +
                "subject=" + subject +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

测试类

public class ShallowCopy {

    public static void main(String[] args) {
        Subject subject = new Subject("语文");

        Student studentA = new Student();
        studentA.setSubject(subject);
        studentA.setName("Jack");
        studentA.setAge(15);

        Student studentB = (Student)studentA.clone();
        studentB.setName("Lily");
        studentB.setAge(18);

        Subject subjectB = studentB.getSubject();
        subjectB.setName("历史");

        System.out.println("StudentA:"+studentA);
        System.out.println("StudentB:"+studentB);
    }

}

输出结果

StudentA:Student{subject=Subject{name='历史'}, name='Jack', age=15}
StudentB:Student{subject=Subject{name='历史'}, name='Lily', age=18}

由输出的结果可见，通过 studentA.clone() 拷贝对象后得到的 studentB，和 studentA 是两个不同的对象。studentA 和 studentB 的基础数据类型的修改互不影响，而引用类型 subject 修改后是会有影响的。

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

public class MainTest {

    public static void main(String[] args) {
        Subject subject = new Subject("语文");

        Student studentA = new Student();
        studentA.setSubject(subject);
        studentA.setName("Jack");
        studentA.setAge(15);

        Student studentB = studentA;
        studentB.setName("Lily");
        studentB.setAge(18);

        Subject subjectB = studentB.getSubject();
        subjectB.setName("历史");

        System.out.println("StudentA:"+studentA);
        System.out.println("StudentB:"+studentB);
    }

}

这里把 Student studentB = (Student) studentA.clone() 换成了 Student studentB = studentA

输出结果：

StudentA:Student{subject=Subject{name='历史'}, name='Lily', age=18}
StudentB:Student{subject=Subject{name='历史'}, name='Lily', age=18}

可见，对象拷贝后没有生成新的对象，二者的对象地址是一样的；而浅拷贝的对象地址是不一样的。

深拷贝

介绍

通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 studentB 的 subject，但是 studentA 的 subject 也被修改了，因为它们都是指向的同一个地址。所以，此种情况下，我们需要用到深拷贝。

深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。

特点

1、对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）

2、对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。

3、对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。

4、深拷贝相比于浅拷贝速度较慢并且花销较大。

结构图：

java 深拷贝工具类多层对象_java 深拷贝工具类多层对象_03

代码实现

对于 Student 的引用类型的成员变量 Subject ，需要实现 Cloneable 并重写 clone() 方法

public class Subject implements Cloneable{

    private String name;

    public Subject(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Subject{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        // Subject 如果也有引用类型的成员属性，也应该和 Student 类一样实现
        return super.clone();
    }
}

在 Student 的 clone() 方法中，需要拿到拷贝自己后产生的新的对象，然后对新的对象的引用类型再调用拷贝操作，实现对引用类型成员变量的深拷贝。

public class Student implements Cloneable{

    // 引用类型
    private Subject subject;

    // 基础数据类型
    private String name;

    // 基础数据类型
    private int age;

    public Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.subject = subject;
    }

    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 Object clone(){
        try {
            Student student = (Student)super.clone();
            student.subject = (Subject) subject.clone();
            return student;
        }catch (CloneNotSupportedException e){
            return null;
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "subject=" + subject +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

一样的测试方法

public class DeepClone {

    public static void main(String[] args) {
        Subject subject = new Subject("语文");

        Student studentA = new Student();
        studentA.setSubject(subject);
        studentA.setName("Jack");
        studentA.setAge(15);

        Student studentB = (Student)studentA.clone();
        studentB.setName("Lily");
        studentB.setAge(18);

        Subject subjectB = studentB.getSubject();
        subjectB.setName("历史");

        System.out.println("StudentA:"+studentA);
        System.out.println("StudentB:"+studentB);
    }
}

输出结果：

StudentA:Student{subject=Subject{name='语文'}, name='Jack', age=15}
StudentB:Student{subject=Subject{name='历史'}, name='Lily', age=18}

由输出结果可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：windows的nginx怎么添加ngx_http_geoip2_module模块

下一篇：南京南瑞软件开发java笔试题

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯