Java深浅拷贝介绍

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量3w 收藏 2
点赞数 2
分类专栏： Java技术 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25409421/article/details/131151371
版权

浅拷贝

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象.换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。

原理示意图：

 

要实现对象浅拷贝还是比较简单的，只需要被复制类需要实现 Cloneable 接口，重写 clone 方法即可，对 User类进行改造，使其可以支持浅拷贝。

代码示例：

package main.java.cn.test;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:04:25
 * @description
 */
public class User implements Cloneable{

    // 姓名
    private String name;
    // 年龄
    private int age;
    // 邮件
    private String email;
    // 描述
    private String desc;

    public User(String name,int age,String email,String desc){
        this.name = name;
        this.age = age;
        this.email = email;
        this.desc = desc;
    }
    /*
     * 重写 clone 方法，需要将权限改成 public ，直接调用父类的 clone 方法就好了
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}


package main.java.cn.test;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:03:02
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 初始化一个对象
        User user= new User("张三",20,"123456@qq.com","我是张三");
        // 复制对象
        User user1 = (User) user.clone();
        // 改变 user1 的属性值
        user1.setName("我是张三的克隆对象");
        // 修改 user age 的值
        user1.setAge(22);
        System.out.println("user对象："+user.toString());
        System.out.println();
        System.out.println("usere1对象："+user1.toString());

    }
}

改造很简单只需要让 User 继承 Cloneable 接口，并且重写 clone 方法即可，clone 也非常简单只需要调用 object 的 clone 方法就好，唯一需要注意的地方就是 clone 方法需要用 public 来修饰。

输出结果：

user对象：User{name='张三', age=20, email='123456@qq.com', desc='我是张三'}

usere1对象：User{name='我是张三的克隆对象', age=22, email='123456@qq.com', desc='我是张三'}

结果解读：

看到这个结果，你是否有所质疑呢？说好的引用对象只是拷贝了地址，为啥修改了 user1对象的 name 属性值，user对象没有改变？这里就是一个非常重要的知识点了，原因在于：「String、Integer 等包装类都是不可变的对象，当需要修改不可变对象的值时，需要在内存中生成一个新的对象来存放新的值，然后将原来的引用指向新的地址，所以在这里我们修改了 user1对象的 name 属性值，user1对象的 name 字段指向了内存中新的 name 对象，但是我们并没有改变 user对象的 name 字段的指向，所以 user 对象的 name 还是指向内存中原来的 name 地址，也就没有变化」。

这种引用是一种特列，因为这些引用具有不可变性，并不具备通用性，所以我们就自定义一个类，来演示浅拷贝，我们定义一个 UserDesc 类用来存放user 对象中的 desc 字段，，然后在 user 对象中引用 UserDesc 类。

示例代码：

package main.java.cn.test;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:13:00
 * @description
 */
public class UserDesc {

    // 描述
    private String desc;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

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


package main.java.cn.test;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:04:25
 * @description
 */
public class User implements Cloneable{

    // 姓名
    private String name;
    // 年龄
    private int age;
    // 邮件
    private String email;
    // 描述
    private UserDesc userDesc;

    public User(String name,int age,String email,String desc){
        this.name = name;
        this.age = age;
        this.email = email;
        this.userDesc = new UserDesc();
        this.userDesc.setDesc(desc);
    }
    /*
     * 重写 clone 方法，需要将权限改成 public ，直接调用父类的 clone 方法就好了
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public void setDesc(String desc) {
        this.userDesc.setDesc(desc);
    }
    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public UserDesc getUserDesc() {
        return userDesc;
    }

    public void setUserDesc(UserDesc desc) {
        this.userDesc = desc;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", userDesc='" + userDesc.toString() + '\'' +
                '}';
    }
}


package main.java.cn.test;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:03:02
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 初始化一个对象
        User user= new User("小宁",20,"123456@qq.com","小宁的博客");
        // 复制对象
        User user1 = (User) user.clone();
        // 改变 user1 的属性值
        user1.setName("我是小宁的克隆对象");
        // 修改 user age 的值
        user1.setAge(22);
        user1.setDesc("我已经关注了小宁的博客啦");
        System.out.println("user对象："+user.toString());
        System.out.println();
        System.out.println("usere1对象："+user1.toString());

    }
}

运行 main 方法，得到如下结果：

user对象：User{name='小宁', age=20, email='123456@qq.com', userDesc='UserDesc{desc='我已经关注了小宁的博客啦'}'}

usere1对象：User{name='我是小宁的克隆对象', age=22, email='123456@qq.com', userDesc='UserDesc{desc='我已经关注了小宁的博客啦'}'}

结果解读：

我们修改 user1 的 desc 字段之后，user 的 desc 也发生了改变，这说明 user 对象和 user1 对象指向是同一个 UserDesc 对象地址，这也符合浅拷贝引用对象只拷贝引用地址并未创建新对象的定义，到这你应该知道浅拷贝了吧。

深拷贝

被复制对象的所有变量都含有与原来的对象相同的值。而那些引用其他对象的变量将指向被复制过的新对象。而不再是原有的那些被引用的对象.换言之.深拷贝把要复制的对象所引用的对象都复制了一遍.

原理示意图：


深拷贝有两种方式，一种是跟浅拷贝一样实现 Cloneable 接口，另一种是实现 Serializable 接口，用序列化的方式来实现深拷贝，我们分别用这两种方式来实现深拷贝。

 实现Cloneable接口方式

实现 Cloneable 接口的方式跟浅拷贝相差不大，我们需要引用对象也实现 Cloneable 接口。

具体代码改造如下：

package main.java.cn.test.clone.deep;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:13:00
 * @description
 */
public class UserDesc implements Cloneable{

    // 描述
    private String desc;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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


package main.java.cn.test.clone.deep;


/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:04:25
 * @description
 */
public class User implements Cloneable{

    // 姓名
    private String name;
    // 年龄
    private int age;
    // 邮件
    private String email;
    // 描述
    private UserDesc userDesc;

    public User(String name, int age, String email, String desc){
        this.name = name;
        this.age = age;
        this.email = email;
        this.userDesc = new UserDesc();
        this.userDesc.setDesc(desc);
    }
    /*
     * 重写 clone 方法，需要将权限改成 public ，直接调用父类的 clone 方法就好了
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        // 需要将引用对象也克隆一次
        user.userDesc = (UserDesc)userDesc.clone();
        return user;
    }
    public void setDesc(String desc) {
        this.userDesc.setDesc(desc);
    }
    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public UserDesc getUserDesc() {
        return userDesc;
    }

    public void setUserDesc(UserDesc desc) {
        this.userDesc = desc;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", userDesc='" + userDesc.toString() + '\'' +
                '}';
    }
}


package main.java.cn.test.clone.deep;


/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:03:02
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 初始化一个对象
        User user= new User("小宁",20,"123456@qq.com","小宁的博客");
        // 复制对象
        User user1 = (User) user.clone();
        // 改变 user1 的属性值
        user1.setName("我是小宁的克隆对象");
        // 修改 user age 的值
        user1.setAge(22);
        user1.setDesc("我已经关注了小宁的博客啦");
        System.out.println("user对象："+user.toString());
        System.out.println();
        System.out.println("usere1对象："+user1.toString());

    }
}

我们再次运行 main 方法，得到如下结果：


user对象：User{name='小宁', age=20, email='123456@qq.com', userDesc='UserDesc{desc='小宁的博客'}'}

usere1对象：User{name='我是小宁的克隆对象', age=22, email='123456@qq.com', userDesc='UserDesc{desc='我已经关注了小宁的博客啦'}'}

结果解读：

可以看出，修改 user1 的 desc 时对 user 的 desc 已经没有影响了，说明进行了深拷贝，在内存中重新生成了一个新的对象。

实现 Serializable 接口方式

实现 Serializable 接口方式也可以实现深拷贝，而且这种方式还可以解决多层克隆的问题，多层克隆就是引用类型里面又有引用类型，层层嵌套下去，用 Cloneable 方式实现还是比较麻烦的，一不小心写错了就不能实现深拷贝了，使用 Serializable 序列化的方式就需要所有的对象对实现 Serializable 接口，我们对代码进行改造，改造成序列化的方式

package main.java.cn.test.clone.deep;

import java.io.*;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 11:00:58
 * @description
 */
public class UserDescBySerializable  implements Serializable {
    private static final long serialVersionUID = 872390113109L;
    // 描述
    private String desc;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

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


package main.java.cn.test.clone.deep;

import java.io.*;

/**
 * @author ningzhaosheng
 * @date 2023/6/11 11:04:29
 * @description
 */
public class UserBySerializable implements Serializable {
    private static final long serialVersionUID = 369285298572941L;
    // 姓名
    private String name;
    // 年龄
    private int age;
    // 邮件
    private String email;
    // 描述
    private UserDescBySerializable userDesc;

    public UserBySerializable(String name, int age, String email, String desc){
        this.name = name;
        this.age = age;
        this.email = email;
        this.userDesc = new UserDescBySerializable();
        this.userDesc.setDesc(desc);
    }

    public UserBySerializable clone()  {
        UserBySerializable user  = null;
        try {
            // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            // 将流序列化成对象
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            user = (UserBySerializable) ois.readObject();

        }catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return user;
    }
    public void setDesc(String desc) {
        this.userDesc.setDesc(desc);
    }
    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 getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public UserDescBySerializable getUserDesc() {
        return userDesc;
    }

    public void setUserDesc(UserDescBySerializable desc) {
        this.userDesc = desc;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", userDesc='" + userDesc.toString() + '\'' +
                '}';
    }
}


package main.java.cn.test.clone.deep;


/**
 * @author ningzhaosheng
 * @date 2023/6/11 10:03:02
 * @description
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 初始化一个对象
        //User user= new User("小宁",20,"123456@qq.com","小宁的博客");
        UserBySerializable user = new UserBySerializable("小宁",20,"123456@qq.com","小宁的博客");
        // 复制对象
        //User user1 = (User) user.clone();
        UserBySerializable user1 = user.clone();
        // 改变 user1 的属性值
        user1.setName("我是小宁的克隆对象");
        // 修改 user age 的值
        user1.setAge(22);
        user1.setDesc("我已经关注了小宁的博客啦");
        System.out.println("user对象："+user.toString());
        System.out.println();
        System.out.println("usere1对象："+user1.toString());

    }
}

运行结果：


user对象：User{name='小宁', age=20, email='123456@qq.com', userDesc='UserDesc{desc='小宁的博客'}'}

usere1对象：User{name='我是小宁的克隆对象', age=22, email='123456@qq.com', userDesc='UserDesc{desc='我已经关注了小宁的博客啦'}'}

我们可以得到跟 Cloneable 方式一样的结果，序列化的方式也实现了深拷贝。

夜夜流光相皎洁_小宁
关注
专栏目录
在Java中实现深拷贝与浅拷贝
m0_75198698的博客
05-28 447
在 Java 中，可以使用不同的方式来实现深拷贝和浅拷贝。我将为你提供几种常见的方法。**浅拷贝（Shallow Copy）**： 浅拷贝是创建一个新对象，然后将原始对象的字段值复制给新对象的字段。这意味着新对象和原始对象共享相同的引用类型字段，因此修改其中一个对象的引用类型字段可能会影响到另一个对象。下面是使用 `clone()` 方法实现浅拷贝的示例代码：```java class Person implements Cloneable { private String name; pr
java基础05：浅拷贝和深拷贝
stan_ko的博客
02-26 1409
关于深拷贝与浅拷贝的概念解释，以及如何实现深浅拷贝
Java的深浅拷贝机制
CoderGAP
02-15 1217
Java的深浅拷贝机制
Java中的深浅拷贝
qq_53026081的博客
11-10 445
深拷贝作为面试常考的题目，里面确实涉及到了很多细节：考察你的递归能力考察处理循环引用，还可以深入挖掘对weakSet、weakMap弱引用的了解程度考察各种引用类型的处理，对数据类型的掌握的程度。
java:深浅拷贝
qq_45476544的博客
03-30 266
变量实际上代表的就是一块存储空间，拷贝就是将空间里的值完全复制给另一个变量，不管值是什么，都是直接复制过去。如果原变量存储的是基本数据类型，那么原变量存储的是一个值，拷贝过去的就是基本数据类型的值，则变量相互独立；在刚学编程时，一直记得一句话：方法传参时，形参是实参的临时拷贝，但对于什么情况下会影响原数据，什么情况下不会影响原数据，还是很懵。深拷贝：操作拷贝的数据，原数据不会发生变化（变量指向不同的对象，只是对象的属性和方法完全一样）浅拷贝：操作拷贝的数据，原数据也会发生变化（变量指向同一个对象）
java的深浅拷贝_Java 深浅拷贝
weixin_39541044的博客
02-25 212
1、浅拷贝(同一个引用)：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。2、深拷贝(新引用)：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制...
java深浅拷贝
weixin_47796247的博客
11-10 91
深浅拷贝
深浅拷贝 java_Java深浅拷贝
weixin_34504649的博客
02-28 71
深浅拷贝 Java1. 前提深浅拷贝的前提是当拷贝一个对象时，即生成一个新的对象时。生成一个新的对象，主要有以下工作内存分配一块和被拷贝的类一样的区域划分字段，方法的使用区域将被拷贝类内存里的内容搬到指定区域2. 怎么搬？- 前提中说到把被拷贝类内存里的内容搬到新的区域，怎么搬呢？我的理解就是简单的赋值。```javaclass Person{public int age;public Strin...
Java深浅拷贝
weixin_73869209的博客
12-25 980
引用拷贝通常指的是浅拷贝，即只复制了对象本身，而没有复制对象内部的引用对象。这意味着原始对象和拷贝对象仍然共享相同的引用对象
c python java 复制数组 深浅拷贝
12-22
在不同的语言中，如C、Python和Java，数组复制有深拷贝和浅拷贝两种方式，它们之间的区别在于是否拷贝了底层的数据结构。 在Java中，数组的复制可以通过简单的赋值操作实现，例如`int[] a2 = a1;`。这种方式被称为...
java深浅拷贝的实际应用_Java中的深浅拷贝问题你清楚吗？
06-08
是的，我了解深浅拷贝的概念和实际应用。 在Java中，对象的赋值实际上是对象引用的赋值。当一个对象变量被赋值给另一个对象变量时，两个变量都引用了同一个对象。这就是浅拷贝。 相比之下，深拷贝会创建一个新的...
JAVA 浅拷贝和深拷贝
skystep的博客
08-07 3763
在 java 中，默认的拷贝指的是类重写 Object 类中的 clone 方法，调用该方法进行拷贝。使用 clone 方法生生成新的对象，此时在堆中产生新的对象，clone 存放了该对象的引用。对浅拷贝进行加强，对象中引用属性进行 clone 操作，以下例子 User 类 clone 的时候也对 animal 进行拷贝。深拷贝相对于浅拷贝而言，会对所有数据类型都进行拷贝一份，包括这个对象所包含的内部对象。User 类实现 Serializable 接口，对堆区中的实例进行读写，从而实现对实例的全部拷贝。.
在Javascript和Java中浅拷贝和深拷贝
weixin_46925850的博客
10-30 191
在Javascript和Java中浅拷贝和深拷贝
Java对象深浅拷贝详解与实例
"这篇文档详细解释了Java中的对象拷贝，包括浅拷贝和深拷贝的概念，并通过实例展示了如何实现。" 在Java编程中，对象拷贝是一个关键概念，尤其是当你需要创建一个对象的独立副本，使得原对象和副本在后续修改时互不...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 198
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 138
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot 实现图片加水印
心猿意码
11-11 301
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 381
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 476
在方法、构造函数或块内部定义的变量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值