Java深克隆和浅克隆的使用和区别

最新推荐文章于 2023-05-18 15:12:40 发布
最新推荐文章于 2023-05-18 15:12:40 发布
阅读量104 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bernardGao94/article/details/129458297
版权

背景

Java中想要复制对象时，需要考虑到一个问题：如果是引用类型对象，如果只是通过一般的“=”赋值，那么因为只是把引用地址给了新对象，所以改变新对象时会因为实际改变的引用地址指向的对象，因此难免出现改变源对象的属性。例如：

public class Demo1 {
    static class People {
        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 "People{" +
                    "name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        People people1 = new People();
        people1.setName("zhangsan");
        people1.setAge("23");
        System.out.println("源对象：" + people1);
        People people2 = people1;
        System.out.println("新对象：" + people2);
        people2.setName("lisi");
        System.out.println("修改后的源对象：" + people1);
        System.out.println("修改后的新对象：" + people2);
    }
}

结果：

源对象：People{name='zhangsan', age='23'}
新对象：People{name='zhangsan', age='23'}
修改后的源对象：People{name='lisi', age='23'}
修改后的新对象：People{name='lisi', age='23'}

因此这时就需要考虑解决办法，如何把源对象的属性给新对象，而且两个对象改变属性时又可以不相互影响？

概念

Java复制对象的实现方式中有个“克隆”的概念，就是复制一个对象的副本，而克隆又分浅克隆和深克隆。

  • 浅克隆：克隆一个新对象，但是属性如果是引用类型对象则用的同一个引动地址指向的对象。
  • 深克隆：克隆一个新对象，包括引用类型的属性内存地址指向的也是新创建的对象。

实现步骤：

  • 实现Clonable接口；
  • 重写clone()方法。
  • 调用clone()方法克隆对象。

浅克隆

1、验证是否为新对象

bean(未重写toString()，用来验证克隆出的对象是否为新的)

public class People implements Cloneable {
    private String name;
    private int age;

    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
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

main

    public static void main(String[] args) throws CloneNotSupportedException {
        People old = new People();
        old.setName("zhangsan");
        old.setAge(23);
        People clone = (People) old.clone();
        System.out.println("源对象：" + old);
        System.out.println("新对象：" + clone);
    }

结果：地址不同，所以clone的新对象和原来的不是同一个

源对象：com.company.bean.People@4554617c
新对象：com.company.bean.People@74a14482

 2、验证引用类型属性是否为新的

Car

public class Car implements Cloneable {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

People

public class People implements Cloneable {
    private String name;
    private int age;
    private Car car;

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    //修改权限为：public
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

main

    public static void main(String[] args) throws CloneNotSupportedException {
        People old = new People();
        old.setName("zhangsan");
        old.setAge(23);
        Car car = new Car();
        car.setName("ferrari");
        car.setColor("red");
        old.setCar(car);
        People clone = (People) old.clone();
        System.out.println("源对象：" + old);
        System.out.println("新对象：" + clone);
    }

结果：虽然对象是新的，但是clone的属性还是用一个。

源对象：People{name='zhangsan', age=23, car=com.company.bean.Car@4554617c}
新对象：People{name='zhangsan', age=23, car=com.company.bean.Car@4554617c}

深克隆：重写对象中引用类型属性clone()

Car

public class Car implements Cloneable {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //重写clone
    @Override
    public  Car clone() throws CloneNotSupportedException {
        return (Car) super.clone();
    }
}

People

public class People implements Cloneable {
    private String name;
    private int age;
    private Car car;

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    //重写clone方法
    @Override
    public People clone() throws CloneNotSupportedException {
        People people = (People) super.clone();
        people.car = car.clone();
        return people;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

main

    public static void main(String[] args) throws CloneNotSupportedException {
        People old = new People();
        old.setName("zhangsan");
        old.setAge(23);
        Car car = new Car();
        car.setName("ferrari");
        car.setColor("red");
        old.setCar(car);
        People clone = (People) old.clone();
        System.out.println("源对象：" + old);
        System.out.println("新对象：" + clone);
    }

结果：引用类型属性也是新的

源对象：People{name='zhangsan', age=23, car=com.company.bean.Car@4554617c}
新对象：People{name='zhangsan', age=23, car=com.company.bean.Car@74a14482}

补充：序列化方式实现

Car

public class Car implements Serializable {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

}

People

public class People implements Serializable {
    private String name;
    private int age;
    private Car car;

    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 Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", car=" + car +
                '}';
    }
}

main

   public static void main(String[] args) throws IOException, ClassNotFoundException {
        People old = new People();
        old.setName("zhangsan");
        old.setAge(23);
        Car car = new Car();
        car.setName("ferrari");
        car.setColor("red");
        old.setCar(car);
        System.out.println("源对象：" + old);
        //序列化
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(outputStream);
        oos.writeObject(old);
        //反序列化
        ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(inputStream);
        People clone = (People) ois.readObject();
        System.out.println("新对象：" + clone);
    }

结果：和深克隆一样，对象和引用类型属性的地址都是新的。

源对象：People{name='zhangsan', age=23, car=com.company.bean.Car@4554617c}
新对象：People{name='zhangsan', age=23, car=com.company.bean.Car@2d98a335}
偶遇急雨洗心尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实例分析java对象中浅克隆和深克隆
08-26
在本篇文章中我们给大家分享了关于java对象中浅克隆和深克隆的相关知识点和相关代码内容，有兴趣的朋友们学习下。
java 对象的克隆（浅克隆和深克隆）
08-29
主要介绍了java 对象的克隆的相关资料,这里对浅克隆和深克隆进行了实例分析需要的朋友可以参考下
【java开发系列】—— 深克隆和浅克隆
wuxiaopengnihao1的博客
08-17 180
Java支持我们对一个对象进行克隆，通常用在装饰模式和原型模式中。那么什么是深克隆，什么是浅克隆呢。
神奇克隆术——Java深、浅Clone
秋梦尘的博客
04-13 3159
本篇博客通过一个不断加强银行系统的例子来详细阐述了Java中深、浅Clone的区别，优点和缺陷。代码详细，分析细致。并提供了Java源码示例下载。希望我们一起在讨论中共同进步。
Java对象克隆——浅克隆和深克隆的区别
刘剑峰的博客
08-06 2万+
在Java中对象的克隆有深克隆和浅克隆之分。有这种区分的原因是Java中分为基本数据类型和引用数据类型，对于不同的数据类型在内存中的存储的区域是不同的。基本数据类型存储在栈中，引用数据类型存储在堆中。 什么是克隆 克隆就是依据已经有的数据，创造一份新的完全一样的数据拷贝。 实现克隆有多种方式，可以手工的new出一个新的对象，然后将原来的对象信息一个一个的set到新的对
Java设计模式（四）创建型- 原型模式（史上最全浅克隆深克隆）克隆破坏单例解决办法与使用场景以及优缺点
最新发布
移动端开发与最新技术
05-18 181
原型模式
Java的浅拷贝和深拷贝
qq_60361946的博客
08-07 624
java的浅拷贝和深拷贝学习
java 深克隆 浅克隆
11-28
java 深克隆 浅克隆
java 深克隆与浅克隆
09-11
学习java深克隆与浅克隆，希望对你有用
解析JAVA深度克隆与浅度克隆的区别详解
09-05
本篇文章是对JAVA深度克隆与浅度克隆的区别进行了详细的分析介绍，需要的朋友参考下
Java 深克隆和浅克隆
MustWinner的博客
08-08 548
Java 深克隆和浅克隆 一、为什么要克隆？ 使用场景: 当使用一个对象的属性时，需要进行一些修改，但是又不能直接修改该对象，此时我们就可以使用克隆来拷贝一个对象，进行操作。不然就需要new一个对象，对属性赋值。 总的来说为了保证引用类型的参数不被其他方法修改，可以使用克隆后的值作为参数传递。 一般情况下，我们实际需要使用的是深克隆。二、如何克隆三、代码** 浅克隆 运行结果 深克隆 结果 回顾一下浅克隆和深克隆的概念浅克隆是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象里面包含
深克隆和浅克隆的区别
weixin_44351616的博客
06-06 6752
介绍了深克隆和浅克隆的一些区别以及展示代码
Java中浅克隆和深克隆之异同
sc179的博客
02-27 1070
1 概述 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址； 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址； 异同点： 深浅克隆都会在堆中新分配一块区域； 区别在于对象属性引用的对象是否需要进行克隆（递归性的）。 示例 pos:当前对象的地址； son:son属性所指向的地址； name:对象的name属性。 ...
java中浅克隆与深克隆解析
1+1=王的博客
12-10 3733
文章目录简介浅克隆深克隆嵌套使用clone()方法序列化方式浅克隆和深克隆的比较 简介 所谓克隆，就是指依照已存在的数据，复制出一份一样的数据。 java中的克隆有浅克隆和深克隆之分，造成这种区别是因为java中对于基本数据类型和引用类型类型的存储是不一样的，基本数据类型存储在栈中，而引用数据类型存储在堆中，因此造成了在克隆时的不同操作。 实现克隆的方法可以按照三步进行： 实现Clonable接口； 重写clone()方法。 调用clone()方法克隆对象。 浅克隆 package test; imp
深克隆及浅克隆
weixin_43923202的博客
09-18 192
浅克隆 a = [1,2,3,4] let b = a; 深克隆 a = [1,2,3,4] let b = JSON.parse(JSON.stringify(a))
Java浅克隆与深克隆-clone
Keep It Simple Stupid
04-01 1699
Java克隆-clone-深克隆浅克隆
JAVA 克隆
chxxej5675的博客
04-26 81
1. 拷贝 在 java 拷贝一个对象 时，引用为同一内存地址，当改变一个对象时会对原来对象也会产生影响 /** * 对象拷贝 */ private static void test1() { Car car =new Car("奔驰", 3.16, "黑色",45.6)...
浅析Java中的深克隆和浅克隆
Mollychin的博客
01-02 2099
说实话，目前为止还没在项目中遇到过关于Java深克隆和浅克隆的场景。今天手抖戳开了花呗账单，双十二败家的战绩真是惨不忍睹，若能在我的客户端“篡改”下账单金额，那该（简）有（止）多（做）好（梦）啊！于是乎，有了以下的设想。采用工厂模式，根据所传入的帐户名accountName 得到账单bill返回客户端client，代码实现如下： 账单类Bill /** * @Author: mollychi...
彻底理解Java深克隆和浅克隆的原理及实现
热门推荐
lovezhaohaimig的博客
05-19 3万+
一、为什么要克隆？答案是：克隆的对象可能包含一些已经修改过的属性,保留着你想克隆对象的值，而new出来的对象的属性全是一个新的对象，对应的属性没有值，所以我们还要重新给这个对象赋值。即当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个nat...
java深克隆和浅克隆
05-10
在 Java 中，对象的克隆分为深克隆和浅克隆两种方式。 浅克隆是指将对象复制一份，但仅复制对象本身和其中的基本类型数据，而不复制对象中的引用类型数据。这意味着，如果原对象中有引用类型的数据，那么复制出来的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值