Java中的深复制和浅复制

最新推荐文章于 2024-10-14 10:26:35 发布
最新推荐文章于 2024-10-14 10:26:35 发布
阅读量176 收藏
点赞数
分类专栏： Java相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LaoJiuJun/article/details/98510646
版权

深复制和浅复制也称为深拷贝和浅拷贝。简单的说就是创建一个和当前对象一模一样的对象。在日常编码的过程中使用的几率并不多，但在面试中却会被经常问到。

了解深复制和浅复制的原理后，可以帮助我们对Java中的值传递和引用传递有更深刻的理解。

浅复制

下面的实例中，我们创建一个原始类Monster，调用对象的clone方法复制一个新的对象。
注意：要调用对象的clone方法，需要让类实现Cloneable接口，并重写clone方法

public class Monster implements Cloneable{
    private String name;        //怪物名称
    private int level;          //怪物级别
    private Point position;     //怪物坐标

    public Monster(String name, int level){
        this.name = name;
        this.level = level;
        position = new Point(100, 100);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //Cloneable接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中 clone()方法的，
        //如果 clone类没有实现 Cloneable接口，并调用了 Object的 clone()方法
        //（即调用super.clone()方法），那么Object的 clone()方法就会抛出 CloneNotSupportedException异常。
        return super.clone();
    }

    public String getName() {
        return name;
    }

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

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public Point getPosition() {
        return position;
    }

    public void setPosition(int x, int y) {
        position.setX(x);
        position.setY(y);
    }
}
class Point{//坐标类
    private int x;
    private int y;

    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }

}

public class MonsterTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Monster monster1 = new Monster("史莱克", 99);
        //通过clone方法，将对象monster1中的值复制到对象monster2
        Monster monster2 = (Monster)monster1.clone();
        //1.monster1和monster2是两个对象,下面的结果是false
        System.out.println(monster1.equals(monster2));
        //2.对比对象中的值（浅复制中，只复制了对象的引用）
        System.out.println(monster1.getName() == monster2.getName());
        System.out.println(monster1.getName().hashCode());
        System.out.println(monster2.getName().hashCode());
        //巩固第二点，修改monster2的坐标值
        monster2.setPosition(111, 111);
        //monster2的坐标值修改后，对象monster1的坐标值也被修改了
        System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
    }
}

我们可以通过这个例子体会浅复制的特点：
被复制对象的所有成员属性都有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
即浅复制后，新对象的地址变了，但新对象中字段（属性）所指向的内存地址（引用）却没变，新旧对象的字段指向了同一块内存空间。

深复制

深复制则是指在clone对象本身，也clone对象中中的属性（字段）
我们可以通过下面的代码体会：

public class Monster implements Cloneable{
    private String name;
    private int level;
    private Point position;

    public Monster(String name, int level){
        this.name = name;
        this.level = level;
        position = new Point(100, 100);
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Monster monster = (Monster)super.clone();
        //对象属性也通过clone方法复制-深复制
        monster.position = (Point)position.clone();
        return monster;
    }

    public String getName() {
        return name;
    }

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

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public Point getPosition() {
        return position;
    }

    public void setPosition(int x, int y) {
        position.setX(x);
        position.setY(y);
    }
}
class Point implements Cloneable{
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //作为属性类同样实现clone方法，就实现了深复制
        return super.clone();
    }
}

public class MonsterTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Monster monster1 = new Monster("史莱克", 99);
        //通过clone方法，将对象monster1中的值复制到对象monster2
        Monster monster2 = (Monster)monster1.clone();
        //1.monster1和monster2是两个对象,下面的结果是false - 同浅复制
        System.out.println(monster1.equals(monster2));
        //2.对比对象中的值（浅复制中，只复制了对象的引用） - 浅复制
        System.out.println(monster1.getName() == monster2.getName());
        System.out.println(monster1.getName().hashCode());
        System.out.println(monster2.getName().hashCode());
        //修改monster2的坐标值
        monster2.setPosition(111, 111);
        //深复制后，monster2的坐标值修改，对象monster1的坐标值并没有被修改
        System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
    }
}

上面的代码虽然实现了深复制，但是有个瑕疵，就是如果Monster类中出现自定义的引用类型属性（字段），这个引用类型就需要实现Cloneable接口并重写clone方法。引用类型多的情况下，会增加代码量。

实现深复制的另一种方法就是使用序列化技术：
序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。

注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Monster implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int level;
    private Point position;

    public Monster(String name, int level){
        this.name = name;
        this.level = level;
        position = new Point(100, 100);
    }

    //深复制
    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();
    }

    public String getName() {
        return name;
    }

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

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public Point getPosition() {
        return position;
    }

    public void setPosition(int x, int y) {
        position.setX(x);
        position.setY(y);
    }
}
class Point implements Serializable{
    private static final long serialVersionUID = 1L;
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

public class MonsterTest {
    public static void main(String[] args) throws Exception {
        Monster monster1 = new Monster("史莱克", 99);
        //调用自定义的deepClone方法（深复制），将对象monster1中的值复制到对象monster2
        Monster monster2 = (Monster)monster1.deepClone();
        //1.monster1和monster2是两个对象,下面的结果是false 
        System.out.println(monster1.equals(monster2));
        //2.对比对象中的值
        System.out.println(monster1.getName() == monster2.getName());
        System.out.println(monster1.getName().hashCode());
        System.out.println(monster2.getName().hashCode());
        //修改monster2的坐标值
        monster2.setPosition(111, 111);
        //深复制后，monster2的坐标值修改，对象monster1的坐标值并没有被修改
        System.out.println(monster1.getPosition().getX() + "\t" + monster1.getPosition().getY());
    }
}

安装遇到问题，可加老九君个人QQ：614940318，请备注来自CSDN
老九学堂免费C、C++、Java课程地址： https://study.163.com/courses-search?keyword=老九学堂

老九君
关注
专栏目录
java 序列化 transient_Java对象表示方式1：序列化、反序列化和transient关键字的作用...
weixin_33356544的博客
02-13 86
平时我们在Java内存中的对象，是无 法进行IO操作或者网络通信的，因为在进行IO操作或者网络通信的时候，人家根本不知道内存中的对象是个什么东西，因此必须将对象以某种方式表示出来，即 存储对象中的状态。一个Java对象的表示有各种各样的方式，Java本身也提供给了用户一种表示对象的方式，那就是序列化。换句话说，序列化只是表示对 象的一种方式而已。OK，有了序列化，那么必然有反序列化，我们先看一下序...
关于java深层复制和浅层复制
weixin_40476233的博客
03-22 320
今天打了复制的代码主要点就是实现Cloneable接口并重写代码。关于深层和浅层代码的复制可以这样理解比喻：一个人穿了三件衣服，另外一个人也想穿和他一样的外套，这就是浅层复制。如果想和他穿一模一样的三件衣服时，就是深层复制。代码实现：先建一个属性类public class Food implements Cloneable{ public Chicken chicken; public Str...
java中的浅复制和深复制
haidi8
11-17 632
浅复制：只复制基本数据类型，对于引用类型不能实现浅复制的效果。 代码： package com.qf.day13.price.object; public class TestObject { public static void main(String[] args) { Student stu1 = new Student("张三",22); stu1.name="李四"; System.out.println(stu1); Student stu2 =(Student) stu1.c
Java中的浅复制和深复制
鹿与森的博客
11-19 543
一、浅复制与深复制概念 （1）浅复制 浅复制会复制“被复制对象”基本类型的值和对象的引用。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 （2）深复制 深复制会复制“被复制对象”基本类型的值，对象的引用将重新指向一个被复制过的新对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 二、clone()、Cloneable和Serialiable （1）clone()...
java深复制和浅复制
小虎博客
03-04 558
在java中,复制也是就clone()方法,在使用过程中根据业务的需要会有深复制和浅复制之分.那到底什么时候用深复制什么时候用浅复制,以及怎么实现呢?得从复制的概念一起总结一下: 概念: 1,浅复制 所有复制对象的所有变量都有与原对象相同的值,引用对象指向原来的对象.(默认继承object,没有实现clone()方法的类为浅复制). 2,深复制 所有复制对象的所有变量都有与原对象相同的值
Java中的深拷贝和浅拷贝
wd90119的博客
02-06 882
浅拷贝和深拷贝的主要区别在于如何处理引用类型的字段。浅拷贝只复制引用，而不复制引用的对象，而深拷贝则复制引用的对象，从而创建一个完全独立的对象副本。在选择使用浅拷贝还是深拷贝时，需要考虑对象之间的关系以及修改对象时对其他对象的影响。二、应用场景。
Java中的数据复制——详解浅拷贝与深拷贝
最新发布
m0_53926113的博客
10-14 1089
在 Java 中，浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是两个重要概念，尤其在操作对象或数据结构时，它们决定了如何复制数据，以及数据之间是否存在关联。这意味着深拷贝将创建完全独立的副本，即使内部嵌套了复杂的对象结构，原对象和副本之间也不会共享引用。，但如果对象内部有引用类型字段（例如数组、集合、对象），那么这些引用类型字段不会被复制，它们只是被共享。换句话说，浅拷贝只是复制对象的引用，而不是引用指向的实际对象。复制对象的第一层，引用类型字段共享同一对象。
java集合深度复制_Java深度复制List内容。
weixin_42340136的博客
02-24 1196
最近在工作的时候，有一个小需求，需要复制List的内容，然后会改变其中的数据，但是试了几种复制的方法，都是将原有的数据和复制后的数据都改变了，都没有达到我想要的效果。其中涉及到了 “浅复制”和“深复制”的概念，这里不多说，可以参考这篇浅复制和深复制。我只记录了这一个深复制的代码，网上找的其它的深复制，好像不起作用。下面是代码：/*** 深度拷贝* @param src* @param <&g...
Java中的深拷贝与浅拷贝
m0_54187478的博客
01-22 1187
在Java中，深拷贝和浅拷贝是处理对象复制时常见的两种方法，它们在处理对象内部引用时有本质的区别。
理解java中的深复制和浅复制
09-02
在Java编程中，深复制和浅复制是两个重要的概念，主要涉及到对象的复制与克隆。这两个术语在处理对象的拷贝时具有不同的含义，理解它们对于编写高效且无误的代码至关重要。 首先，让我们来看一下浅复制（Shallow ...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
Java对象深复制与浅复制实例详解
08-30
Java对象深复制与浅复制是Java编程中两个重要的概念，它们都是对象复制的方式，但它们有着不同的实现机制和应用场景。在本文中，我们将详细介绍Java对象深复制与浅复制的概念、实现机制、应用场景和示例代码。 浅...
Java中对象的深复制（深克隆）和浅复制（浅克隆）介绍
09-03
为了实现深复制，你需要在需要复制的对象中重写`clone()`方法，或者创建一个专门的深复制方法，手动处理所有引用对象的复制。注意，`Object`类的`clone()`方法默认实现是浅复制，如果需要深复制，必须自行实现。同时...
Java 浅复制和深复制的实例详解
08-29
在本文中，我们介绍了 Java 浅复制和深复制的实例详解，通过代码示例和结果分析，我们可以看到浅复制和深复制的区别和应用场景。浅复制适用于简单的对象复制，而深复制适用于需要完全复制对象的场景。
【工具】Astah Professional 8安装教程
LaoJiuJun的博客
08-05 9907
1、下载软件压缩包文件，首先点击“astah-professional-8_0_0-d641d4-jre-64bit-setup.exe”安装原版程序 32位：https://pan.baidu.com/s/19NBG2KQ-UubaOwuVtql_FA 分享码：scd7 64位：https://pan.baidu.com/s/1cSIoJOUwGPrhFODRNWPfeA 分享码：fqbx 2...
System.arraycopy()方法及对象的深复制和浅复制
LaoJiuJun的博客
08-05 1156
1、System.arraycopy方法实现数组的复制 1-1：System中提供了一个native静态方法arraycopy()，可以使用这个方法实现数组之间的复制。对于普通的一维数组来说，会复制每个数组的值到另一个数组中，即每个元素都是按值传递，修改副本不会影响原来的值。方法原型及复制复制基本类型数组的示例如下： /** * System.arraycopy的方法原型 * @param s...
CentOS中安装配置Java开发环境（非OpenJDK）
LaoJiuJun的博客
08-05 927
本文通过在Oracle官网的JDK1.8安装及配置Java开发环境，不使用OpenJDK 1、卸载系统自带的OpenJDK及相关的Java文件 1-1:使用管理员登录服务器，键入命令： java -version 可以看到系统自带的OpenJDK信息 1-2：键入命令： rpm -qa | grep java rpm是管理套件命令，-qa表示使用询问模式查询所有套件；grep表示查询文件里符合...
在Eclipse中配置中文JavaDoc
LaoJiuJun的博客
08-05 678
第一步：准备配置所需的资源 JDK1.8 API 中文 谷歌翻译版：点击下载 CHM反编译工具 1.0：点击下载 package-list：点击下载（需要解压缩） 第二步：解压chm文件以及CHM反编译工具并打开CHMFBY.exe： 选择好CHM文件后点击“解包”，注意存放路径的设置 解包时会短暂无响应，完毕后D:\JavaDoc1.8\（默认D:\CHM\）会有如下的文件： 第三步：将解包...
Java深复制与浅复制详解
在浅复制中，当原始对象的某个属性是基本类型时，复制的是这些属性的值；如果属性是引用类型，那么复制的是引用，而不是引用的对象。所以，修改副本对象的引用属性会影响到原始对象。 深复制（Deep Copy）： 深复制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值