【Java深拷贝和浅拷贝】

最新推荐文章于 2023-11-16 08:58:56 发布
最新推荐文章于 2023-11-16 08:58:56 发布
阅读量135 收藏 1
点赞数 1
文章标签： java java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ll31523837790/article/details/124182318
版权

Java深拷贝和浅拷贝

深拷贝和浅拷贝都是对象拷贝

浅拷贝

：在进行对象拷贝时，仅仅只拷了一层对象，而其子对象则不会拷贝，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象

public class ShallowCopy {
    public static void main(String[] args) {
        Parents parents = new Parents();
        parents.setName("kong");
        parents.setAge("34");

        Child child = new Child();
        child.setUsername("Dream");
        child.setId(1);
        child.setParents(parents);

        Child child2 = (Child) child.clone();
        System.out.println("拷贝后");
        System.out.println(child2.getUsername());
        System.out.println(child2.getId());
        System.out.println(child2.getParents().getName());
        System.out.println(child2.getParents().getAge());
        System.out.println("修改父母的信息后-------------");

        // 修改父母的信息
        parents.setName("Jam");
        System.out.println(child.getParents().getName());
        System.out.println(child2.getParents().getName());

    }

}
class Parents implements Cloneable{
    private String name;
    private String age;

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Parents{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }
}
class Child implements Cloneable{
    private String username;
    private int id;
    private Parents parents;

    public Parents getParents() {
        return parents;
    }

    public void setParents(Parents parents) {
        this.parents = parents;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getId() {
        return id;
    }

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

    //浅拷贝
    @Override
    public Child clone() {
        try {
            return (Child) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

远行结果：
远行结果
分析：以上代码可以看出，child和child2不是同一个对象，但是当修改父母的信息时，再输出Child类的parents属性值时，两个不同的对象的parents属性值都被修改了。
画图分析：
在这里插入图片描述

深拷贝

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。深拷贝把要复制的对象所引用的对象都复制了一遍。
第一种方法：

package Copy;

public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Parents parents = new Parents();
        parents.setName("kong");
        parents.setAge("34");

        Child child = new Child();
        child.setUsername("Dream");
        child.setId(1);
        child.setParents(parents);

        Child child2 = (Child) child.clone();
        System.out.println("拷贝后");
        System.out.println(child2.getUsername());
        System.out.println(child2.getId());
        System.out.println(child2.getParents().getName());
        System.out.println(child2.getParents().getAge());
        System.out.println("修改父母的信息后-------------");

        // 修改父母的信息
        parents.setName("Jam");
        System.out.println(child.getParents().getName());
        System.out.println(child2.getParents().getName());

    }

}
class Parents implements Cloneable{
    private String name;
    private String age;

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Parents{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    @Override
    public Parents clone() {
        try {
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return (Parents) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
class Child implements Cloneable{
    private String username;
    private int id;
    private Parents parents;

    public Parents getParents() {
        return parents;
    }

    public void setParents(Parents parents) {
        this.parents = parents;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getId() {
        return id;
    }

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

//    @Override
//    public Child clone() {
//        try {
//            // TODO: copy mutable state here, so the clone can't change the internals of the original
//            return (Child) super.clone();
//        } catch (CloneNotSupportedException e) {
//            throw new AssertionError();
//        }
//    }
    public Object clone() throws CloneNotSupportedException {
        // 改为深复制
        Child child2 = (Child) super.clone();
        // 本来是浅复制，现在将Parents对象复制一份并重新set进来
        child2.setParents(child2.getParents().clone());
        return child2;
    }
}

远行结果：
在这里插入图片描述
分析：两个引用child和child2指向不同的两个对象，两个引用child和child2中的两个parents引用指向的是两个对象，但对parents对象的修改只能影响child2对象,所以说是深拷贝。
画图分析：
在这里插入图片描述

第二种方法：类实现Serializable接口
代码如下:

package Copy;

import java.io.*;

public class ShallowCopy {
    public static void main(String[] args) throws Exception {
        Parents parents = new Parents();
        parents.setName("kong");
        parents.setAge("34");
        Child child = new Child();
        child.setUsername("Dream");
        child.setId(1);
        child.setParents(parents);

        Child child2 = (Child) child.deepClone();
        System.out.println("拷贝后");
        System.out.println(child2.getUsername());
        System.out.println(child2.getId());
        System.out.println(child2.getParents().getName());
        System.out.println(child2.getParents().getAge());
        System.out.println("修改父母的信息后-------------");

        // 修改父母的信息
        parents.setName("Jam");
        System.out.println(child.getParents().getName());
        System.out.println(child2.getParents().getName());

    }

}
class Parents implements Serializable {
    private String name;
    private String age;

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Parents{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

//    @Override
//    public Parents clone() {
//        try {
//            // TODO: copy mutable state here, so the clone can't change the internals of the original
//            return (Parents) super.clone();
//        } catch (CloneNotSupportedException e) {
//            throw new AssertionError();
//        }
//    }
}
class Child implements Serializable{
    private String username;
    private int id;
    private Parents parents;

    public Parents getParents() {
        return parents;
    }

    public void setParents(Parents parents) {
        this.parents = parents;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getId() {
        return id;
    }

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

//    @Override
//    public Child clone() {
//        try {
//            // TODO: copy mutable state here, so the clone can't change the internals of the original
//            return (Child) super.clone();
//        } catch (CloneNotSupportedException e) {
//            throw new AssertionError();
//        }
//    }
//    public Object clone() throws CloneNotSupportedException {
//        // 改为深复制
//        Child child2 = (Child) super.clone();
//        // 本来是浅复制，现在将Parents对象复制一份并重新set进来
//        child2.setParents(child2.getParents().clone());
//        return child2;
//    }
    public Object deepClone() throws Exception {
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

远行结果:

在这里插入图片描述

廖磊�
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的深拷贝和浅拷贝介绍
09-03
对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或全部 数据。Java中有三种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)、延迟拷贝(Lazy Copy)
java 深拷贝与浅拷贝机制详解
08-31
主要介绍了 java 深拷贝与浅拷贝机制详解的相关资料,需要的朋友可以参考下
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
主要介绍了Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍,需要的朋友可以参考下
java深入理解浅拷贝和深拷贝
12-21
拷贝对象是java中经常会遇到的问题。java中存在两种类型，基础类型和引用类型。 java的赋值都是传值的，对于基础类型来说，会拷贝具体的内容，但是对于引用对象来说，存储的这个值只是指向实际对象的地址，拷贝也只会拷贝引用地址。 因为引用对象的存在，所以经常会出现和预期不一样的情况。 本文将会深入的探讨一下在拷贝对象中会出现的浅拷贝和深拷贝的情况。 拷贝接口 java中所有的对象都是继承自java.lang.Object。Object对象中提供了一个clone方法，来供我们对java对象进行拷贝。 protected native Object clone() throws CloneNot
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
今天小编就为大家分享一篇关于Java Clone深拷贝与浅拷贝的两种实现方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java 深度clone
欢迎来到 HsienChin 的博客
01-14 271
public Object deepClone() throws IOException, ClassNotFoundException{ //将对象写到流里 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOu...
深浅拷贝各种实现方式性能
干嘛卷来卷去的博客
06-07 611
结论：两种常见的序列化方式 竟然都比 BeanUtil.copyProperties 性能高，fastjson 性能较 beanCopy 高出约7倍，jackson 性能较 beanCopy 高出约3.5倍。BeanUtils 采用 spring 框架自带的，apache commons 性能更低。
Java序列化方式深克隆
生而为人我很抱歉
01-18 464
public static Object copyOfDeep(Object obj){ ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(obj); oos.
【commons-lang3专题】005- ObjectUtils 专题
訾博（ZiBo）的博客
07-28 1196
【commons-lang3专题】005- ObjectUtils 专题
java json clone_FastJSON 与克隆
weixin_42471590的博客
02-16 995
阿里巴巴的开源工具包FastJSON在处理JSON数据的时候非常好用，然而我最近实习中使用的时候发现了一处非常容易中招的陷阱：拷贝问题。举例来说：比如我先有一个Json对象a是这样的JSONObject a = new JSONObject();a.put("key1","value1");然后我需要一个跟a的值一样的新的JSON对象，发现可以直接newJSONObject b = new JSO...
实体类clone方法，赋值对象修改属性值时不改动原数据
weixin_43063239的博客
09-27 554
1.给实体类添加 implements Cloneable 接口 实现 clone方法 @Override public 实体类名 clone() throws CloneNotSupportedException { return (实体类名)super.clone(); } 使用：实体类对象.clone(); 返回新的对象 2.使用spring的utile方法 BeanUtils.copyProperties(已有对象, 目标对象); ...
JAVA：两种序列化实现深拷贝的方法的性能进行比较
weixin_42783740的博客
06-17 438
本文主要对JAVA中两种序列化实现深拷贝的方法的性能进行比较
java中将一个实体类复制到另一个实体类的三种方法
Bombradish的博客
05-26 1万+
java中将一个实体类复制到另一个实体类的三种方法
【面试】深拷贝与浅拷贝的实现原理
DreamSun的博客
04-11 1121
深拷贝与浅拷贝的问题，也是面试中的常客。虽然大家都知道两者表现形式不同点在哪里，但是很少去深究其底层原理，也不知道怎么才能优雅的实现一个深拷贝。其实工作中也常常需要实现深拷贝，今天就带大家一块深入剖析一下深拷贝与浅拷贝的实现原理，并手把手教你怎么优雅的实现深拷贝。浅拷贝： 只拷贝栈内存中的数据，不拷贝堆内存中数据。深拷贝： 既拷贝栈内存中的数据，又拷贝堆内存中的数据。
基础面试题:深拷贝和浅拷贝详解以及实例
热门推荐
Venus's Blog
04-30 4万+
深拷贝 vs 浅拷贝 浅拷贝 概念 复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象。 如图： ​ 特点 ​ 1.对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。 2.对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝...
Java 中FastJson的使用【吃透FastJson】
单枪匹码
02-13 2556
JSON序列化、反序列化JavaBean的框架有很多，最常见的Jackson、阿里巴巴开源的FastJson、谷歌的GSON、apache提供的json-lib等，下面我们主要来熟悉一下：Java语言中FastJson的使用。
Java 实体类之间的互相复制
最新发布
Matrix的博客
11-16 2288
与 Apache BeanUtils 一样，Spring BeanUtils 也是通过将源对象的属性值复制到目标对象的对应属性来实现的。2.BeanUtils：Apache BeanUtils 是一个常用的 Java 类库，可以用于快速实现 Java Bean 之间的互相赋值。使用该库可以将源对象的属性值复制到目标对象的对应属性，不需要编写大量的重复代码。4.Dozer：Dozer 是一个强大的 Java Bean 映射框架，可以用于 Java Bean 之间的自动转换。
2020-09-14 fastjson对象初始化clone和new set性能对比
baixf的博客
09-14 610
@Test public void testFastJsonClone(){ int forNumber = 3000; // 粗略测试 keysize >5之后性能会更有优势 int keySize = 5; long start2 = System.currentTimeMillis(); JSONObject jsonObjectClone = new JSONObject(); for (int i1 = 0; i1 < keySize; i1++) {
java(20)---克隆
猿累人生
11-01 248
java支持我们对一个对象进行克隆,那么什么是克隆？ 1、什么是克隆？ Java中的克隆分为深克隆和浅克隆 浅克隆：仅仅复制它所考虑的对象,而不复制它所引用的对象。 深克隆：不仅要复制它所考虑的对象,而且还要复制它所引用的对象。 2、为什么要克隆？ 引入问题1：为什么要克隆,直接new一个对象不好吗？ new出来的对象，该对象的属性值都是初始化的时候的值。 克隆出来
JAVA深拷贝和浅拷贝
09-05
- *2* *3* [Java 浅拷贝和深拷贝的理解和实现方式](https://blog.csdn.net/weixin_30662011/article/details/96181137)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值