JAVA浅克隆和深克隆

已于 2024-08-12 19:28:44 修改
阅读量720 收藏 4
点赞数 15
分类专栏： # Java基础 文章标签： java
于 2024-08-12 19:07:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44824164/article/details/140804748
版权

文章目录

前言

克隆的使用场景主要为需要将对象将源对象复制一份出来，保证后续改动不会对源对象造成影响。
浅克隆复制基本类型变量，改动克隆对象引用对象属性，会对源对象造成影响。
深克隆复制基本类型变量和引用类型变量，和源对象完全分割，改动克隆对象不会影响源对象。

一、浅克隆

1. 实体对象

package com.student.model;

/**
 * Create by zjg on 2024/7/30
 */
public class Student {
    private int id;
    private String name;
    private int age;
    private String gender;
    private Address address;
    public Student() {
    }
    public Student(int id, String name, int age, String gender, Address address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getGender() {
        return gender;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

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

    public static class Address implements Cloneable{
        private String province;
        private String city;
        private String area;
        public Address(String province, String city, String area) {
            this.province = province;
            this.city = city;
            this.area = area;
        }

        public String getProvince() {
            return province;
        }

        public void setProvince(String province) {
            this.province = province;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }

        public String getArea() {
            return area;
        }

        public void setArea(String area) {
            this.area = area;
        }

        @Override
        public String toString() {
            return "Address{" +
                    "province='" + province + '\'' +
                    ", city='" + city + '\'' +
                    ", area='" + area + '\'' +
                    '}';
        }
    }
}

2. 单元测试

package test.z202401;

import com.student.model.Student;
import org.springframework.beans.BeanUtils;

/**
 * Create by zjg on 2024/7/30
 */
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student=new Student(1,"张三",18,"男",new Student.Address("北京","北京","朝阳区"));
        Student clone = new Student();
        BeanUtils.copyProperties(student,clone);
        System.out.println("修改前------");
        System.out.println(student);
        System.out.println(clone);
        clone.setId(2);//修改克隆对象的id
        clone.setName("李四");//修改克隆对象的名字
        Student.Address address = clone.getAddress();
        address.setProvince("山东省");//修改克隆对象的省
        address.setCity("济南市");//修改克隆对象的市
        address.setArea("市中区");//修改克隆对象的区
        clone.setAddress(address);
        System.out.println("修改后------");
        System.out.println(student);
        System.out.println(clone);
    }
}

3. 输出

修改前------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
修改后------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='山东省', city='济南市', area='市中区'}}
Student{id=2, name='李四', age=18, gender='男', address=Address{province='山东省', city='济南市', area='市中区'}}

我们修改了克隆对象的id,name和address对象，对象1的id和name没有发生变化，但是对于我们自定义的Address对象修改却影响了对象1的数据，可见它们使用的是同一个Address对象。

二、深克隆

深度克隆有Cloneable和Serializable两种实现方式，都能解决上述问题，接下来我们逐个介绍

1. Cloneable

1.1 实体对象

package com.student.model;

/**
 * Create by zjg on 2024/7/30
 */
public class Student implements Cloneable{
    private int id;
    private String name;
    private int age;
    private String gender;
    private Address address;
    public Student() {
    }
    public Student(int id, String name, int age, String gender, Address address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getGender() {
        return gender;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
    public Object clone() throws CloneNotSupportedException {
        Student student = (Student)super.clone();
        student.address = (Address)this.address.clone();
        return student;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", address=" + address +
                '}';
    }

    public static class Address implements Cloneable{
        private String province;
        private String city;
        private String area;
        public Address(String province, String city, String area) {
            this.province = province;
            this.city = city;
            this.area = area;
        }

        public String getProvince() {
            return province;
        }

        public void setProvince(String province) {
            this.province = province;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }

        public String getArea() {
            return area;
        }

        public void setArea(String area) {
            this.area = area;
        }
        public Object clone() throws CloneNotSupportedException {
            Address address = (Address)super.clone();
            return address;
        }
        @Override
        public String toString() {
            return "Address{" +
                    "province='" + province + '\'' +
                    ", city='" + city + '\'' +
                    ", area='" + area + '\'' +
                    '}';
        }
    }
}

1.2 单元测试

package test.z202401;

import com.student.model.Student;

/**
 * Create by zjg on 2024/7/30
 */
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student=new Student(1,"张三",18,"男",new Student.Address("北京","北京","朝阳区"));
        Student clone = (Student)student.clone();
        System.out.println("修改前------");
        System.out.println(student);
        System.out.println(clone);
        clone.setId(2);//修改克隆对象的id
        clone.setName("李四");//修改克隆对象的名字
        Student.Address address = clone.getAddress();
        address.setProvince("山东省");//修改克隆对象的省
        address.setCity("济南市");//修改克隆对象的市
        address.setArea("市中区");//修改克隆对象的区
        clone.setAddress(address);
        System.out.println("修改后------");
        System.out.println(student);
        System.out.println(clone);
    }
}

1.3 输出

修改前------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
修改后------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
Student{id=2, name='李四', age=18, gender='男', address=Address{province='山东省', city='济南市', area='市中区'}}

可以看出修改克隆对象的属性，不会对原对象造成影响

2. Serializable

2.1 实体对象

package com.student.model;

import java.io.Serializable;

/**
 * Create by zjg on 2024/7/30
 */
public class Student implements Serializable {
    private int id;
    private String name;
    private int age;
    private String gender;
    private Address address;
    public Student() {
    }
    public Student(int id, String name, int age, String gender, Address address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getGender() {
        return gender;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

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

    public static class Address implements Serializable {
        private String province;
        private String city;
        private String area;
        public Address(String province, String city, String area) {
            this.province = province;
            this.city = city;
            this.area = area;
        }

        public String getProvince() {
            return province;
        }

        public void setProvince(String province) {
            this.province = province;
        }

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }

        public String getArea() {
            return area;
        }

        public void setArea(String area) {
            this.area = area;
        }

        @Override
        public String toString() {
            return "Address{" +
                    "province='" + province + '\'' +
                    ", city='" + city + '\'' +
                    ", area='" + area + '\'' +
                    '}';
        }
    }
}

2.2 单元测试

package test.z202401;

import com.student.model.Student;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Create by zjg on 2024/7/30
 */
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student student=new Student(1,"张三",18,"男",new Student.Address("北京","北京","朝阳区"));
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(student);

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        Student clone = (Student)ois.readObject();
        System.out.println("修改前------");
        System.out.println(student);
        System.out.println(clone);
        clone.setId(2);//修改克隆对象的id
        clone.setName("李四");//修改克隆对象的名字
        Student.Address address = clone.getAddress();
        address.setProvince("山东省");//修改克隆对象的省
        address.setCity("济南市");//修改克隆对象的市
        address.setArea("市中区");//修改克隆对象的区
        clone.setAddress(address);
        System.out.println("修改后------");
        System.out.println(student);
        System.out.println(clone);
    }
}

2.3 输出

修改前------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
修改后------
Student{id=1, name='张三', age=18, gender='男', address=Address{province='北京', city='北京', area='朝阳区'}}
Student{id=2, name='李四', age=18, gender='男', address=Address{province='山东省', city='济南市', area='市中区'}}

实现序列化接口，通过对象流产生的对象也是不会对原对象产生影响。

总结

回到顶部

深度克隆的两种使用方式略有区别，大家可以根据自己的使用习惯来

实践是检验真理的唯一标准。

java 深克隆 浅克隆
11-28
java 深克隆 浅克隆
java中浅克隆与深克隆解析
1+1=王的博客
12-10 4020
文章目录简介浅克隆深克隆嵌套使用clone()方法序列化方式浅克隆和深克隆的比较 简介 所谓克隆，就是指依照已存在的数据，复制出一份一样的数据。 java中的克隆有浅克隆和深克隆之分，造成这种区别是因为java中对于基本数据类型和引用类型类型的存储是不一样的，基本数据类型存储在栈中，而引用数据类型存储在堆中，因此造成了在克隆时的不同操作。 实现克隆的方法可以按照三步进行： 实现Clonable接口； 重写clone()方法。 调用clone()方法克隆对象。 浅克隆 package test; imp
实例分析java对象中浅克隆和深克隆
08-26
浅克隆和深克隆在Java对象中的应用 在Java编程语言中，克隆（Clone）是一种常见的对象复制机制。克隆可以分为浅克隆（Shallow Clone）和深克隆（Deep Clone）两种。浅克隆仅复制对象的引用，而深克隆则完全复制对象...
java 对象的克隆（浅克隆和深克隆）
08-29
总结起来，Java对象的克隆机制是创建对象副本的一种手段，分为浅克隆和深克隆。浅克隆只复制对象的基本类型字段，而引用字段指向的是原始对象的引用。深克隆则会递归地复制所有字段，包括引用类型的字段，确保副本与...
java 深克隆与浅克隆
09-11
Java 深克隆与浅克隆 Java 中的克隆机制可以让我们方便地制造出一个对象的副本来，但是在克隆过程中需要注意浅克隆和深克隆的区别。 浅克隆（Shallow Clone）是指对对象的域进行简单的 copy，对象的reference变量...
Java浅克隆与深克隆
12-22
Java中的浅克隆和深克隆是对象复制的两种方式，它们主要区别在于对对象内部引用类型字段的处理。在Java中，实现克隆通常需要重写`Object`类的`clone()`方法。 **浅克隆（Shallow Clone）** 浅克隆创建一个新对象，...
JAVA浅克隆与深克隆
04-07
测试类`Test.java`可以用来验证浅克隆和深克隆的效果，比如改变克隆对象的属性并检查原始对象是否受影响。 总结来说，Java中的克隆机制对于复制对象和维护对象状态的独立性至关重要。浅克隆适用于不涉及复杂引用...
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
深入JAVA对象深度克隆的详解
09-05
在Java中，深度克隆与浅克隆的区别在于处理对象内部引用的复杂性。浅克隆只复制对象本身，而不复制它所引用的对象，而深度克隆则会递归地复制对象及其引用的所有子对象。 当对象包含复杂的数据结构，如集合或嵌套的...
深入理解Java中的克隆
09-01
要正确地实现克隆，需要理解浅拷贝和深拷贝的区别，并根据需求选择合适的复制策略。同时，需要注意`Cloneable`接口的使用以及`clone()`方法的重写，以避免`CloneNotSupportedException`异常。在处理包含可变引用类型...
object-cloner:克隆一个 Java 对象。 支持浅克隆和深克隆
06-23
支持可扩展的浅层和深层对象克隆策略。用法下面是一个关于如何使用库的示例 // Example TestObject clone = new ObjectCloner().deepClone(originalTestObject);有关更多示例，请参阅 junit 测试用例。Maven将以下...
Java中对象的深复制（深克隆）和浅复制（浅克隆）介绍
09-03
2. **深复制（深克隆）**：不仅复制对象本身，还递归地复制所有引用的对象。这样，复制后的对象及其所有引用的对象都是独立的，修改一个不会影响另一个。 为了实现深复制，你需要在需要复制的对象中重写`clone()`...
Java实现克隆的三种方式实例总结
08-27
Java提供了三种方式来实现克隆：浅克隆、深克隆和使用Serializable实现深克隆。下面我们将对这三种方式进行详细的分析和实例讲解。 浅克隆（浅复制） 浅克隆是指将一个对象的所有成员变量值复制到另一个对象中，但...
理解java中的深复制和浅复制
09-02
在Java编程中，深复制和浅复制是两个重要的概念，主要涉及到对象的复制与克隆。这两个术语在处理对象的拷贝时具有不同的含义，理解它们对于编写高效且无误的代码至关重要。 首先，让我们来看一下浅复制（Shallow ...
浅析Java中clone()方法浅克隆与深度克隆
08-30
在Java中，克隆分为两种类型：浅克隆（Shallow Clone）和深度克隆（Deep Clone）。 1. 浅克隆（Shallow Clone） 浅克隆是Java克隆机制的默认行为。当一个对象被克隆时，如果它的成员变量是基本类型（如int、double...
解析JAVA深度克隆与浅度克隆的区别详解
09-05
/* 浅克隆 */ newSimpleClone = (SimpleClone)super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return newSimpleClone; } ``` 在这个例子中，`SimpleClone`类有一个`Clone...
java 深克隆浅克隆
09-30
Java提供了两种主要的克隆方式：深克隆和浅克隆。 1. 浅克隆（Shallow Clone）： 浅克隆是通过调用对象的`clone()`方法来实现的，这个方法是Object类提供的。当一个对象被浅克隆时，新创建的对象将拥有原始对象的...
Java对象的深克隆与浅克隆详解.zip(wcb2003)
04-27
总的来说，理解Java对象的深克隆和浅克隆是优化代码和解决特定问题的关键。根据具体需求选择合适的克隆方式，可以提高代码的可维护性和灵活性。在设计类和系统时，应考虑对象复制的需求，并决定是否实现`Cloneable`...
Java深克隆与浅克隆详解
总结来说，Java的深克隆和浅克隆是处理对象复制的两种策略。浅克隆适用于对象的属性主要是基本类型的情况，而深克隆则适用于需要完全独立副本，包括复杂类型的场景。理解这两种克隆的概念有助于避免因数据共享导致的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值