Java深(Deep)拷贝与浅(Shadow)拷贝

最新推荐文章于 2025-02-21 15:13:42 发布
最新推荐文章于 2025-02-21 15:13:42 发布
阅读量795 收藏 1
点赞数
分类专栏： # JAVA 文章标签： java 深拷贝 浅拷贝 懒拷贝 deep-copy

Java深(Deep)拷贝与浅(Shadow)拷贝

基本代码

//代码清单1 Address.java
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
//浅拷贝，则Adress不需要实现Cloneable接口
public class Address implements Cloneable {
    private String country;/**国家*/
    private String province;/**省*/
    private String city;/**城市*/

    public Address(String country,String province,String city){
        this.country = country;
        this.province = province;
        this.city = city;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
//代码清单2 Person.java
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Person implements Cloneable {
    private String name;
    private String gender;
    private Address address;

    public Person(String name, String gender, Address address) {
        this.name = name;
        this.gender = gender;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        /**
         * 浅拷贝
         */
        //return super.clone();

        /**
         * 深拷贝
         */
        Person p = (Person)super.clone();
        //把所有是引用类型的字段再拷贝一次
        address = (Address) p.getAddress().clone();
        return p;
    }
}

浅拷贝

浅拷贝(shadow copy)即按位拷贝对象。新对象通过精确拷贝源对象值的方式被创建出来。假如对象具有引用类型的字段，那么只会拷贝引用地址(内存地址;reference addresses or memory address)。

shadow_copy

如上图，结合代码清单1和2。在上图中person拥有字段name、gender和address，其中address是引用类型。对person进行浅拷贝后产生person2，person2仍然指向address。

经过观察发现，原始数据类型经过浅拷贝后，会生成新的一份数据，上图中是name->name1;gender->gender2。而address是一个Address对象，是引用类型，所以经过浅拷贝后仍旧会指向原来的address。

因此，person内的address经过任何改变，也会在person2中反映出来。

代码实现:

  1. 需要实现Cloneable接口。
  2. 重写clone()方法，返回super.clone();
//代码清单3
public class Main {

    public static void main(String[] args) throws CloneNotSupportedException{
        /**待拷贝的源对象*/
        Address address = new Address("中国","广西省","崇左市");
        Person person = new Person("张三","男",address);
        print("person => %s",person);
        /**拷贝*/
        Person person2 = (Person)person.clone();//拷贝效果看Person的clone()方法的内容。
        print("person2 => %s",person2);
        /**
         * 测试浅/深拷贝特性：
         * 1. 如果源拷贝对象有引用类型的字段，则改变引用类型的字段值，会既影响到源拷贝对象，又影响到clone后的对象
         * 2. 改变原始类型字段值，则不会影响到双方
         */
        address.setProvince("湖南省");
        address.setCity("长沙市");
        person.setName("李四");
        print("\n改变引用类型字段值后:");
        print("person => %s",person);
        print("person2 => %s",person2);

    }
    public static void print(String format,Object... args){
        System.out.println(String.format(format,args));
    }
}

output
person => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))

改变引用类型字段值后:
person => Person(name=李四, gender=男, address=Address(country=中国, province=湖南省, city=长沙市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=湖南省, city=长沙市))

观察输出，浅拷贝结论是：

  1. clone重写只需要返回super.clone();
  2. 源对象和拷贝对象内的引用数据类型字段指向的都是同一个地方。即该字段在任意一个地方改变，都会如实反映在各个拷贝或源对象中。

深拷贝

深拷贝拷贝所有的字段(Fields)，并且拷贝字段指向的动态分类的内存。当一个对象连同它指向的对象被拷贝时，深拷贝就发生了。

deep_copy

在上图中，person拥有字段name、gender、address。当对person进行深拷贝时，name1包含复制name的值，同理gender1和address1都包含复制的gender和address值。address发生任何改变，都不会在address1内发生改变。

代码实现:

  1. 需要实现Cloneable接口（源对象内的引用类型也许要实现Cloneable接口，并重写clone()方法）。
  2. 重写clone()方法。先调用要拷贝对象的clone()方法,然后在调用源对象内引用对象的clone()方法。
 1. 如代码清单2，下面是一些片段
        /**
         * 深拷贝
         */
        Person p = (Person)super.clone();
        //把所有是引用类型的字段再拷贝一次
        address = (Address) p.getAddress().clone();
        return p;
2. 测试代码和代码清单3一模一样

output
person => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))

改变引用类型字段值后:
person => Person(name=李四, gender=男, address=Address(country=中国, province=广西省, city=崇左市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=湖南省, city=长沙市))

深拷贝结论：

  1. 源对象和拷贝对象之间互不影响。无论字段是否是应用类型还是原始数据类型。

序列化实现深拷贝

注意，对象内的所有类都必须实现序列化接口。

1. 代码清单1、2中
   Address.java 、Person.java需要实现Serializable接口
//测试代码如下
public class Main {

    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;

        try {
            // create original serializable object
            Address address = new Address("中国", "广西省", "崇左市");
            Person person = new Person("张三", "男", address);
            // print it
            print("person => %s", person);

            // deep copy
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            // serialize and pass the object
            oos.writeObject(person);
            oos.flush();
            ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bin);
            // return the new object
            Person person2 = (Person) ois.readObject();
            // verify it is the same
            print("person2 => %s", person2);
            // change the original object's contents
            address.setProvince("湖南省");
            address.setCity("长沙市");
            person.setName("李四");
            // see what is in each one now
            print("\n改变引用类型字段值后:");
            print("person => %s", person);
            print("person2 => %s", person2);
        } catch (Exception e) {
            System.out.println("Exception in main = " + e);
        } finally {
            oos.close();
            ois.close();
        }
    }
    public static void print(String format,Object... args){
        System.out.println(String.format(format,args));
    }
}

output
person => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))

改变引用类型字段值后:
person => Person(name=李四, gender=男, address=Address(country=中国, province=湖南省, city=长沙市))
person2 => Person(name=张三, gender=男, address=Address(country=中国, province=广西省, city=崇左市))

不足之处(缺点、局限性)

  1. 不能序列化一个transient变量。
  2. 如果是单例模式，你以这种方式进行深拷贝，则它就不再是单例模式了。
  3. 性能问题。创建一个socket,序列化一个对象，然后通过socket传递它，最后反序列化。不建议这样用，因为它比实现Cloneable慢100倍左右。

懒拷贝(lazy copy)

懒拷贝实际上是深拷贝和浅拷贝的结合体。当初始化的时候，用浅拷贝。一个计数器需要用来追踪有多少个对象共享数据，当应用更改源对象时，它知道数据是否共享，并决定是否要做深拷贝。

懒拷贝从结果看，像极了深拷贝，只是它充分利用了浅拷贝的优势——速度快。当源对象内的引用数据类型字段不经常被更改时，用浅拷贝。

缺点是追踪counter的花销，此外，在特殊情况下，循环引用也会导致问题。

总结

使用场景有：

  1. 使用浅拷贝：对象只有原始数据类型字段；有引用类型的字段，但从不更改它。

  2. 使用深拷贝：有引用类型的字段，且经常被修改。

简言之，使用哪种拷贝方式看需求如何。

其实也可以手动进行深拷贝，或者浅拷贝，即

import org.springframework.beans.BeanUtils

//Copy the property values of the given source bean into the target bean.
    public static void copyProperties(Object source, Object target) throws BeansException {
        copyProperties(source, target, null, (String[]) null);
    }

参考来源

  1. Java深拷贝与浅拷贝
  2. Java深拷贝与浅拷贝
  3. Java深拷贝与浅拷贝
基于非接触式微波雷达设计的跌倒检测预警系统【短信报警】
12-26 678
本项目选择基于非接触式微波雷达的跌倒检测预警装置作为技术核心，采用云帆瑞达的R60AFD1跌倒检测模组。这一模组能够根据人体的运动变化，如速度、距离和姿态等特征，判断是否发生跌倒，并可以持续监控老年人是否处于危险状态。此外，本项目还结合4G通信技术，通过Air724UG模块实现短信报警功能，一旦检测到跌倒事故，系统将自动通过4G网络向紧急联系人发送短信报警，及时通知亲属或医护人员进行救援。
java面向对象编程中可能出现的隐藏hide、遮蔽shadow、遮掩obscure
feinifi的博客
10-13 1878
面向对象编程中隐藏hide,遮蔽shadow,遮掩obscure情形。
IOS开发之深拷贝与浅拷贝(mutableCopy与Copy)详解
weixin_33843409的博客
04-21 128
阅读本文之前首先了解copy与retain的区别，如果有不正确的地方望大家多多指教: copy与retain的区别： copy是创建一个新对象，retain是创建一个指针，引用对象计数加1。Copy属性表示两个对象内容相同，新的对象retain为1 ，与旧有对象的引用计数无关，旧有对象没有变化。copy减少对象对上下文的依赖。 retain属性表示两个对象地址相...
JAVA集成本地部署的DeepSeek
最新发布
weixin_49214500的博客
02-21 5497
前往主页。点击下载，选择对应操作系统，点击下载。下载完成后打开直接无脑下一步就行。安装完成之后打开CMD页面，输入ollama，如果有输出就代表安装成功，如果显示"不是内部命令"就需要配置一下环境变量。###配置环境变量以及更改ollama模型路径###win10系统为例，右键此电脑>高级系统设置>高级>环境变量ollama 默认会安装到 C:\Users\XX\AppData\Local\Programs\ollama 下，将此文件全部移到其他盘。
deep copy & shadow copy
liuyitao0815的博客
02-29 167
1.实现浅拷贝 // 1. …实现 let copy1 = {…{x:1}} // 2. Object.assign实现 let copy2 = Object.assign({}, {x:1}) 2. 实现深拷贝 // 1. JOSN.stringify()/JSON.parse() let obj = {a: 1, b: {x: 3}} JSON.parse(JSON.stringify(obj...
Java-浅拷贝(shadow copy)
张子布
06-05 960
0. 相关：深拷贝 1. 首先Java的clone()方法，我们已经了解 2. 然后之前实现的clone()方法可能对我们的需求有所差异 比如： package com.basis.entity; public class Person implements Cloneable { private String adress; private Info info; ...
深拷贝和浅拷贝 Deep copy and Shadow copy
09-15 786
Objective－C中的copy和c++的一样分深拷贝和浅拷贝，怎样区分这两个对象呢？我的理解是：    （1）深拷贝，就是新拷贝一块内存交给对象使用。    （2）浅拷贝，就是觉得拷贝内存太浪费，直接给你我的地址吧，相当于retain。
lua的深拷贝和浅拷贝
silent_F的博客
03-27 582
代码如下 --- Deep copies a table into a new table. -- Tables used as keys are also deep copied, as are metatables -- @param orig The table to copy -- @return Returns a copy of the input table local functi...
java Clone
07-25
`clone`方法分为两种类型：浅克隆（Shadow Clone）和深克隆（Deep Clone）。浅克隆是指只复制对象本身，而不复制其引用的对象。如果对象中包含其他对象的引用，那么这些引用的对象不会被复制，而是共享同一份引用。...
RTL8370MB在嵌入式系统中的应用案例分析：深度解读与实践心得
[RTL8370MB在嵌入式系统中的应用案例分析：深度解读与实践心得](https://img-blog.csdnimg.cn/20190530142930296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9...
Java备忘录模式：保护和恢复对象状态的设计策略
[Java设计模式的应用与实例](https://img-blog.csdnimg.cn/7dfad362cbdc4816906bdcac2fd24542.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAWmhhbmdTYW5fUGx1cw==,size_...
Java深度拷贝（Deep Copy）和浅拷贝（Shallow Copy）
nbspzs的专栏
12-02 839
/ 深拷贝 Address 对象。Apache Commons Lang 提供了 SerializationUtils 工具来实现深拷贝。可以在类中实现 Cloneable 接口，并在 clone 方法中手动深拷贝所有属性。- 浅拷贝：复制对象的引用，内部的引用类型属性不会被复制，而是共享原对象的引用。- 深拷贝：不仅复制对象本身，还复制对象中的所有引用对象，生成完全独立的副本。- Cloneable 适用于简单对象，但需要手动处理嵌套对象。将对象序列化为字节流，再反序列化为新的对象，确保完全独立。
java 深层复制_Java里的浅拷贝和深层拷贝区别(shadow copy, deep copy)
weixin_42486337的博客
02-12 155
java拷贝引用int a[] = {1,2};int b[] = a;System.out.println(a[0]); //print 1System.out.println(b[0]); //print 1a[0]=10000;System.out.println(a[0]); //print 10000System.out.println(b[0]); //print 10...
java deepcopy_java deep copy
weixin_32816563的博客
02-19 238
//deep copy1、可以对每个成员变量赋值的方式重新将对象的成员值指向新的地址值(比如string)，不能整个对象一起赋值(=)，这样是引用了对象的地址值，修改应用对象时，被引用的也修改了2、 使用工具类 BeanUtils.copyProperties(pifuList1.get(i),bpStation);List pifuList = new ArrayList<>();f...
Java 变量隐藏（Shadow）
www.wuxianjie.net
05-20 2822
Java 变量隐藏（Shadow）引言什么是变量隐藏总结 引言 Java 中的局部类（Local Class，本地类）和匿名类（Anonymous Class）都存在变量隐藏（Shadowing）。 当我们理解变量隐藏之后，将可以更好地理解 Lambda 表达式作用域，因为 Lambda 表达式没有任何的变量隐藏。 什么是变量隐藏 要理解什么是变量隐藏，最好的方式就是通过代码去理解，譬如以下代码：...
Shallow Copy(影子拷贝) VS Deep Copy(深拷贝)
Jason Shen's Column
11-15 2351
Shallow Copy VS Deep Copy
Java Shadowing 影子变量 影子声明
weixin_38833041的博客
07-07 763
如果特定范围（例如内部类或方法定义）中的类型声明（例如成员变量或参数名称）与封闭范围中的另一个声明具有相同的名称，则该声明会隐藏封闭范围中的声明。您不能仅通过名称来引用影子声明。以下示例 ShadowTest 演示了这一点： 以下是此示例的输出： 本例定义了三个名为x的变量：ShadowTest类的成员变量、内部类FirstLevel的成员变量、方法methodInFirstLevel中的参数。定义为方法methodInFirstLevel 的参数的变量 x 隐藏了内部类FirstLevel 的变量 x。因
Java中的深拷贝和浅拷贝
lxsxjsj的博客
12-06 689
在Java中，浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是两种不同的对象复制方式。当person2的address.city被修改时，person1的address.city保持不变，这就是深拷贝的特性。浅拷贝会创建一个新对象，但对于对象内部的引用类型属性，仍然复制其引用而不是创建一个新的独立对象。深拷贝会创建一个新对象，并且递归地复制对象内部的所有引用类型属性，使得新对象与原对象完全独立。深拷贝适用于需要完全独立的对象副本，确保原对象和新对象之间没有引用共享的情况。
赋值、浅拷贝和深拷贝
包龙星的剑
06-15 349
python中为声明一个变量有三种方法：赋值、浅拷贝(shadow copy)、深拷贝(deep copy)，相信每个pythoner或多或少都知道他们之间的区别，但在某些点上，还是会踩坑，这篇文章记录下所有关于这三者区别的疑问。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值