java干货 浅拷贝和深拷贝

已于 2024-06-27 01:44:14 修改
阅读量1.3k 收藏 5
点赞数 41
文章标签： java 开发语言 jvm
于 2024-06-27 01:38:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51305563/article/details/140000610
版权

文章目录

一、浅拷贝

1.1 特点

  • 基本数据类型字段的拷贝：值被复制，新对象和原对象的字段在内存中是不同的
  • 引用类型字段的拷贝：对于引用类型，它们的引用被复制，他们指向同一个内存空间，是同一份数据。
    注意：当引用类型字段发生改变时，不可变引用类型和可变引用类型是不同的，前者是线程安全的，后者是线程不安全的：
    • 如：因为 String 是不可变的，当新对象的String 类型字段 发生变化时，但是原对象的同一String 字段不变。这是因为新对象的String 字段只是指向另一个内存堆空间。如 String a = “123”; String b = a; a = “456”; a 指向的新的内存空间，并不是将“123”所在空间的值改为“456”，这是String 底层使用不可变数组导致的。a 的 改变不会引起b的改变，因此String 是线程安全的

1.2 代码实现

  • 通过构造函数 传递对象 实现浅拷贝 不可变引用类型
class Person {
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Copy constructor for shallow copy
    public Person(Person other) {
        this.name = other.name; // Assigning reference of other.name to this.name
        this.age = other.age;
    }

    // Getters and Setters
    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 static void main(String[] args) {
        Person original = new Person("John", 30);
        Person copy = new Person(original);
        
        System.out.println(original.name == copy.name);
        
        // 改变 拷贝对象的 引用类型字段的值
        copy.setName("Doe");

        System.out.println(original.name == copy.name);
    }
}

true
false

分析：对象original 和 copy 的name 字段通过引用赋值，实现浅拷贝，两个对象的name 引用指向同一内存空间。当修改copy 的name 的值后，两者本应该还是指向同一个内存空间，但是实际却不是。这是因为name 是String 类型，String 不可变，给copy 的name 赋 新的值，实际上是开辟了新的内存空间，copy 的name 指向这一个新空间，而 original 还是指向原来那个空间，那个空间的值没变，也不可变。

修改基本类型的值：

public static void main(String[] args) {
        Person original = new Person("John", 30);
        Person copy = new Person(original);

        System.out.println("original: " + original.toString());
        System.out.println("copy: " + copy.toString());
        // 改变 拷贝对象的 引用类型字段的值
        copy.setAge(5);
        System.out.println("-------------改变copy 的基本类型 值后：-----------------");
        System.out.println("original: " + original.toString());
        System.out.println("copy: " + copy.toString());
    }

运行结果：说明基本类型浅拷贝，不是同一份

original: Person{name='John', age=30}
copy: Person{name='John', age=30}
-------------改变copy 的基本类型 值后：-----------------
original: Person{name='John', age=30}
copy: Person{name='John', age=5}
  • 通过构造函数 传递对象 实现浅拷贝 可变引用类型
class Person {
    private List<String> hobbies;
    private int age;

    // Constructor
    public Person(List<String> hobbies, int age) {
        this.hobbies = hobbies;
        this.age = age;
    }

    // Copy constructor for shallow copy
    public Person(Person other) {
        this.hobbies = other.hobbies; // Reference copy for List (mutable)
        this.age = other.age;         // Value copy for int (primitive)
    }

    // Getters and Setters
    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{hobbies=" + hobbies + ", age=" + age + "}";
    }

    public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("Reading");
        hobbies.add("Swimming");

        Person original = new Person(hobbies, 30);
        Person copy = new Person(original);

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);

        // Modify the hobbies list of the copy
        copy.getHobbies().add("Cycling");

        System.out.println("==============copy.getHobbies().add(\"Cycling\")之后: ==============");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }
}

Original: Person{hobbies=[Reading, Swimming], age=30}
Copy: Person{hobbies=[Reading, Swimming], age=30}
==============copy.getHobbies().add("Cycling")之后: ==============
Original: Person{hobbies=[Reading, Swimming, Cycling], age=30}
Copy: Person{hobbies=[Reading, Swimming, Cycling], age=30}

分析：两个 对象的 List 类引用 始终指向同一个内存空间。copy 的操作list ,list 指向的空间的值发生了改变，两个仍然指向同一个内存空间，获取到的值一样

修改基本类型字段的值： 基本类型经浅拷贝，两个对象各有一份，基本类型字段所在内存空间不相同

public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("Reading");
        hobbies.add("Swimming");

        Person original = new Person(hobbies, 30);
        Person copy = new Person(original);

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);

        copy.setAge(5);

        System.out.println("==============copy.getHobbies().add(\"Cycling\")之后: ==============");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }

Original: Person{hobbies=[Reading, Swimming], age=30}
Copy: Person{hobbies=[Reading, Swimming], age=30}
==============copy.getHobbies().add("Cycling")之后: ==============
Original: Person{hobbies=[Reading, Swimming], age=30}
Copy: Person{hobbies=[Reading, Swimming], age=5}
  • 通过 实现Cloneable接口，重写clone 方法,实现浅拷贝
package com.binbin.copy;
import java.util.ArrayList;
import java.util.List;
class Person implements  Cloneable{
    private List<String> hobbies;
    private int age;

    // Constructor
    public Person(List<String> hobbies, int age) {
        this.hobbies = hobbies;
        this.age = age;
    }

    // Copy constructor for shallow copy
    public Person(Person other) {
        this.hobbies = other.hobbies; // Reference copy for List (mutable)
        this.age = other.age;         // Value copy for int (primitive)
    }

    // Getters and Setters
    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{hobbies=" + hobbies + ", age=" + age + "}";
    }

    @Override
    public Person clone() {
        try {
            Person clone = (Person) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("Reading");
        hobbies.add("Swimming");

        Person original = new Person(hobbies, 30);
        Person copy = new Person(original);

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);

        copy.getHobbies().add("cycle");

        System.out.println("==============copy.getHobbies().add(\"Cycling\")之后: ==============");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }
}

二、深拷贝

2.1 特点

  • 在 Java 中是指创建一个新对象，同时递归地复制所有引用类型的字段，这样使得新对象完全独立于原对象。新对象的引用类型字段指向新的的内存空间，基本类型字段也是新的内存空间
  • 代码实现
import java.util.ArrayList;
import java.util.List;

class Person  {
    private List<String> hobbies;
    private int age;

    // Constructor
    public Person(List<String> hobbies, int age) {
        this.hobbies = new ArrayList<>(hobbies); // Ensure independent copy for constructor
        this.age = age;
    }

    // Deep copy method
    public Person deepCopy() {
        List<String> copiedHobbies = new ArrayList<>(this.hobbies);
        return new Person(copiedHobbies, this.age);
    }

    // Getters and Setters
    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{hobbies=" + hobbies + ", age=" + age + "}";
    }

    public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("Reading");
        hobbies.add("Swimming");

        Person original = new Person(hobbies, 30);
        Person copy = original.deepCopy();

        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);

        // Modify the age of the copy
        copy.setAge(35);

        // Modify the hobbies list of the copy
        copy.getHobbies().add("Cycling");

        System.out.println("After modifications:");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy);
    }
}

Original: Person{hobbies=[Reading, Swimming], age=30}
Copy: Person{hobbies=[Reading, Swimming], age=30}
After modifications:
Original: Person{hobbies=[Reading, Swimming], age=30}
Copy: Person{hobbies=[Reading, Swimming, Cycling], age=35}

分析：original 和 copy 的 hobbies 指向不同内存间，copy的hobbies 修改 不影响 original 的hobbies

三、总结

  • 深拷贝和浅拷贝的区别：深拷贝把给引用类型字段申请新的内存空间，并将原对象的数据复制到新的对象的空间中。浅拷贝只是引用赋值，还是指向同一内存空间
  • 浅拷贝还要考虑 可变引用类型字段 和 不可变引用类型字段
  • 浅拷贝可以实现Cloneable接口，重写clone 方法实现浅拷贝
  • 深拷贝的浅拷贝的基本类型字段拷贝时，都会创建新的空间
小男孩编程
关注
  • 41
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
漫谈deepcopy（深拷贝）和shallowcopy（浅拷贝）
我很帅的专栏
06-15 1万+
浅拷贝：只复制当前的对象，对该对象内部的引用（其他类对象作为自己的元素-也叫对其他对象的引用）不能复制（在堆内存中从新创建空间，内容相同，但地址不同）。 深拷贝：对对象内部的引用均复制，是创建一个新的实例，并复制实例。
Java 的拷贝（深拷贝、浅拷贝）
weiweiqiao的专栏
07-01 2659
在对象的拷贝中，很多初学者可能搞不清到底是拷贝了引用还是拷贝了对象。在拷贝中这里就分为引用拷贝、浅拷贝、深拷贝进行讲述。
小问题6 | Java中如何实现深拷贝？实现深拷贝的三种方法
最新发布
dongangsta的博客
03-05 2984
小问题6 | Java中如何实现深拷贝？实现深拷贝的三种方法
Java中的浅拷贝和深拷贝
qq15035899256的博客
10-07 947
本文是JavaSE的学习，认识什么是拷贝，浅拷贝和深拷贝的区别，实现深拷贝的两种方式。之后的学习内容将持续更新！！！
Java的深浅拷贝机制
CoderGAP
02-15 1171
Java的深浅拷贝机制
Java深浅拷贝
weixin_73869209的博客
12-25 512
引用拷贝通常指的是浅拷贝，即只复制了对象本身，而没有复制对象内部的引用对象。这意味着原始对象和拷贝对象仍然共享相同的引用对象
java干货（有视频）
12-24
java干货，包含 深度解析SpringMvc实现原理手写SpringMvc框架， 手写Tomca之深度解析动态资源请求原理，揭开springAOP神秘面纱之动态代理，网络爬虫之JAVA正则表达式......等视频教程！
Java思维导图干货资料
06-04
Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料Java思维导图干货资料...
Java面试总结_干货
04-06
本人在学习以及面试过程中汇总的干货面试题,可以说看到就是赚到,纯个人手稿
Java自学编程全套干货教学
04-23
Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了...
详解java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝）
08-26
主要介绍了java中的深拷贝和浅拷贝（clone()方法的重写、使用序列化实现真正的深拷贝），文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java干货知识深入理解内部类
08-25
总的来说，内部类是Java提供的一种高级特性，它扩展了类的概念，允许在类内部定义类，从而增强了代码的组织和复用。通过合理使用内部类，我们可以创建更加灵活和模块化的程序结构，解决复杂的设计问题。
Java中的深拷贝与浅拷贝
weixin_47382783的博客
08-18 1954
进行深拷贝时，基本数据类型变量和引用类型变量指向的对象都会被复制，即针对引用类型的成员变量真正的复制一份，重新开辟空间保存，这样两个引用类型属性互不影响。对于浅拷贝而言，在复制对象时仅仅复制对象本身，包括基本属性和引用类型，拷贝出来的对象和原对象中属性所引用的对象是同一个。对于深拷贝而言，复制之后的对象和原对象之间互不影响。......
Java当中的深拷贝和浅拷贝
qq_39939541的博客
07-23 1095
从输出结果可以看出，尽管我们使用BeanUtils进行了拷贝，但person1和person2的属性值仍然是相同的，修改其中一个对象的属性值会同时影响另一个对象的属性值。它会创建一个全新的对象，并将原始对象中的所有属性或元素都复制到新的对象中。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素不会受到任何影响。浅拷贝是一种复制对象到另一个变量的操作，它仅复制对象的地址而非对象本身。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素也会随之改变。
java浅拷贝和深拷贝
qq_38976745的博客
11-30 467
这里写自定义目录标题什么是拷贝关于浅拷贝关于深拷贝简单实现深拷贝、浅拷贝实现浅拷贝实现深拷贝拷贝和new创建对象的性能简单对比欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 什么是拷贝 面试中
Java基础篇--浅拷贝和深拷贝
m0_74293254的博客
08-13 626
选择使用浅拷贝还是深拷贝取决于实际需求。如果希望复制对象后的修改不会影响原始对象，应该使用深拷贝；如果可以接受复制对象的修改影响原始对象，或者对象较大且复制性能要求高，则可以使用浅拷贝。
Java中对象拷贝，对象的浅拷贝、对象的深拷贝
下雨了亦留此地的博客
04-06 3837
Java中对象的浅拷贝、深拷贝
java关于深拷贝和浅拷贝的理解
qq_42077317的博客
06-07 685
对于基本数据类型就是直接进行值传递，在内存的另一个空间内存放，修改这个值不会影响到拷贝源的值，对于引用数据类型就是进行的是地址传递，并没有对该对象重新开辟一个内存空间进行存放，所以对于引用数据类型的浅拷贝就相当于两个引用指向了同一个内存地址。说明浅拷贝不会拷贝引用类型指向的对象，只会拷贝引用，指向的仍是同一个地址，所以这两个对象的引用对象是同一个对象，修改就会发生改变，浅拷贝也就是一个封装性的赋值操作。3.如果对象引用任何时候都不会被改变，那么没必要使用深拷贝，只需要使用浅拷贝就行了。
java文件操作大全.docx
08-30
满满的干货分享，全是代码，只有你想不到，没有我做不到。 代码都可以直接拿来使用，不用重复造轮子，提高开发效率

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值