java 深拷贝和浅拷贝

最新推荐文章于 2023-01-29 22:57:55 发布
最新推荐文章于 2023-01-29 22:57:55 发布
阅读量411 收藏 12
点赞数 3
分类专栏： java基础 文章标签： 深拷贝 浅拷贝 java基础 java 深拷贝和浅拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37664223/article/details/89554492
版权

深拷贝和浅拷贝的问题无非就是拷贝过程中对象的属性是否指向的是同一个对象引用。

浅拷贝的特点：

一：作为基本数据类型来说，例如int ,double等8类数据类型，拷贝过程中肯定是值的传递，修改另一个对象的数值，不会影响到被拷贝对象的数值。
二：String 类型，String 类型虽然是引用类型，但是String类型的数据是存放在常量池中的，也就是无法修改的！当被拷贝的对象进行修改的时候，是把引用指向了新的地址，而不是在原来的地址上进行修改，所以不影响被拷贝的数据。
三：引用数据类型，例如一个对象，如果是浅拷贝，也就是说被拷贝对象和拷贝对象指向的是同一个引用，那么对其中一个对象进行修改，也会改变另一个对象的值。

1：话不多说，上代码~

public class Clones implements Cloneable {
    private String name;
    private int size;
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public Clones(String name, int size, Address address) {
        this.name = name;
        this.size = size;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Clones{" +
                "name='" + name + '\'' +
                ", size=" + size +
                ", address=" + address +
                '}';
    }

    @Override
    protected Object clone()  {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
            return null;
    }

    public static void main(String[] args) {
        Address address=new Address("没修改的地址",123456789);
        Clones clones=new Clones("没修改",123,address);
        Clones copys=(Clones)clones.clone();
        System.out.println(copys==clones);
        System.out.println(clones.getName()==copys.getName());
        System.out.println(clones.getSize()==copys.getSize());
        System.out.println(clones.getAddress()==copys.getAddress());
        System.out.println(clones.getAddress().getEmail()==copys.getAddress().getEmail());
        System.out.println(clones.getAddress().getHost()==copys.getAddress().getHost());
        clones.setName("修改了");
        clones.setSize(10000);
        address.setEmail("修改的邮箱");
        address.setHost(7758521);
        System.out.println("====================修改后======================");

        System.out.println(clones.getName());
        System.out.println(clones.getSize());
        System.out.println(clones.getAddress().toString());


        System.out.println("拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println(copys.getName());
        System.out.println(copys.getSize());
        System.out.println(copys.getAddress().toString());

===========================控制台输出结果====================================================

  /* 
            false
            true
            true
            true
            true
            true
            ====================修改后======================
            修改了
            10000
            Address{email='修改的邮箱', host=7758521}
            拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~
            没修改
            123
            Address{email='修改的邮箱', host=7758521}
*/
===================================================================================
    }
}

class Address{
    String email;
    int host;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getHost() {
        return host;
    }

    public void setHost(int host) {
        this.host = host;
    }

    public Address(String email, int host) {
        this.email = email;
        this.host = host;
    }

    @Override
    public String toString() {
        return "Address{" +
                "email='" + email + '\'' +
                ", host=" + host +
                '}';
    }
}

那么问题来了，怎么实现深拷贝呢，其实有两个实现深拷贝的方式，

  • 方式一： 需要为对象的每一层的每一个对象都实现Cloneable接口并重写clone方法

2：话不多说，继续上代码~


public class Clones implements Cloneable {
    private String name;
    private int size;
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public Clones(String name, int size, Address address) {
        this.name = name;
        this.size = size;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Clones{" +
                "name='" + name + '\'' +
                ", size=" + size +
                ", address=" + address +
                '}';
    }

    @Override
    protected Object clone()  {
        Object obj=null;
        try {
            obj= super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //调用Address 类的clone方法进行深拷贝
        Clones clones=(Clones)obj;
        clones.address=(Address)clones.getAddress().clone();
            return obj;
    }

    public static void main(String[] args) {
        Address address=new Address("没修改的地址",123456789);
        Clones clones=new Clones("没修改",123,address);
        Clones copys=(Clones)clones.clone();
        System.out.println(copys==clones);
        System.out.println(clones.getName()==copys.getName());
        System.out.println(clones.getSize()==copys.getSize());
        System.out.println(clones.getAddress()==copys.getAddress());
        System.out.println(clones.getAddress().getEmail()==copys.getAddress().getEmail());
        System.out.println(clones.getAddress().getHost()==copys.getAddress().getHost());
        clones.setName("修改了");
        clones.setSize(10000);
        address.setEmail("修改的邮箱");
        address.setHost(7758521);
        System.out.println("====================修改后======================");

        System.out.println(clones.getName());
        System.out.println(clones.getSize());
        System.out.println(clones.getAddress().toString());


        System.out.println("拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println(copys.getName());
        System.out.println(copys.getSize());
        System.out.println(copys.getAddress().toString());


===========================控制台输出结果====================================================

  /* 
            false
            true
            true
            true
            true
            true
            ====================修改后======================
            修改了
            10000
            Address{email='修改的邮箱', host=7758521}
            拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~
            没修改
            123
            Address{email='没修改的地址', host=123456789}
*/
===================================================================================
    }
}

class Address implements Cloneable{
    String email;
    int host;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getHost() {
        return host;
    }

    public void setHost(int host) {
        this.host = host;
    }

    public Address(String email, int host) {
        this.email = email;
        this.host = host;
    }

    @Override
    public String toString() {
        return "Address{" +
                "email='" + email + '\'' +
                ", host=" + host +
                '}';
    }


    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
    
}
  • 方式二： 通过对象序列化实现深拷贝
将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

3：话不多说，继续上代码~

public class Clones implements Serializable {
    private String name;
    private int size;
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public Clones(String name, int size, Address address) {
        this.name = name;
        this.size = size;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Clones{" +
                "name='" + name + '\'' +
                ", size=" + size +
                ", address=" + address +
                '}';
    }


    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address=new Address("没修改的地址",123456789);
        Clones clones=new Clones("没修改",123,address);
       //通过序列化方式，实现深拷贝
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(clones);
        oos.flush();
        //反序列化实现深度拷贝
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Clones copys=(Clones)ois.readObject();

        System.out.println(copys==clones);
        System.out.println(clones.getName()==copys.getName());
        System.out.println(clones.getSize()==copys.getSize());
        System.out.println(clones.getAddress()==copys.getAddress());
        System.out.println(clones.getAddress().getEmail()==copys.getAddress().getEmail());
        System.out.println(clones.getAddress().getHost()==copys.getAddress().getHost());
        clones.setName("修改了");
        clones.setSize(10000);
        address.setEmail("修改的邮箱");
        address.setHost(7758521);
        System.out.println("====================修改后======================");

        System.out.println(clones.getName());
        System.out.println(clones.getSize());
        System.out.println(clones.getAddress().toString());


        System.out.println("深拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println(copys.getName());
        System.out.println(copys.getSize());
        System.out.println(copys.getAddress().toString());

===========================控制台输出结果====================================================

  /* 
           false
false
true
false
false
true
====================修改后======================
修改了
10000
Address{email='修改的邮箱', host=7758521}
深拷贝的对象~~~~~~~~~~~~~~~~~~~~~~~~
没修改
123
Address{email='没修改的地址', host=123456789}
*/
===================================================================================
    }
}

class Address implements Serializable {
    String email;
    int host;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getHost() {
        return host;
    }

    public void setHost(int host) {
        this.host = host;
    }

    public Address(String email, int host) {
        this.email = email;
        this.host = host;
    }

    @Override
    public String toString() {
        return "Address{" +
                "email='" + email + '\'' +
                ", host=" + host +
                '}';
    }



}
小十木
关注
专栏目录
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
Java序列化和克隆
make0739的博客
06-07 137
转载：http://hi.baidu.com/en_wan/item/32bf32140b1baafcdceeca92 序列化 Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。...
java map深拷贝_关于HashMap的浅拷贝深拷贝
weixin_31082779的博客
02-16 1248
Map中存储的都是String，不是基本数据类型的，这个有很大影响；putAll()和clone()对基本数据类型的数据是没有问题的，但是引用类型还是不行。HashMap的浅拷贝clone()方法一、创建一个HashMap对象source，进行赋值，然后再克隆一个对象targetMap出来。通过改变targetMap的值，观察source与targetMap的变化。HashMap source =...
java 拷贝 追加_Java中如何克隆集合——ArrayList和HashSet深拷贝
weixin_29285605的博客
02-24 253
编程人员经常误用各个集合类提供的拷贝构造函数作为克隆List，Set，ArrayList，HashSet或者其他集合实现的方法。需要记住的是，Java集合的拷贝构造函数只提供浅拷贝而不是深拷贝，这意味着存储在原始List和克隆List中的对象是相同的，指向Java堆内存中相同的位置。增加了这个误解的原因之一是对于不可变对象集合的浅克隆。由于不可变性，即使两个集合指向相同的对象是可以的。字符串池包含...
java map深度拷贝_java中深复制知识点详解
weixin_42573647的博客
02-16 474
java中深复制知识点详解,序列化,赠品,深度,物品,两个java中深复制知识点详解易采站长站，站长之家为您整理了java中深复制知识点详解的相关内容。在正式开始深复制的讲解之前，我们先来理解一下概念。假设一个物品需要批量生产，但是这个物品还配有赠品，生产的时候需要把赠品也列在计划内。所谓深复制的原理就是这样，我们不能只复制属性，包括引用之类的附带也需要被复制。下面小编就为大家带来深复制的两种不同...
java map深拷贝_java 复制Map对象（深拷贝与浅拷贝）
weixin_39944515的博客
02-13 144
java 复制Map对象(深拷贝与浅拷贝)CreationTime--2018年6月4日10点00分Author:Marydon1.深拷贝与浅拷贝浅拷贝：只复制对象的引用，两个引用仍然指向同一个对象，在内存中占用同一块内存；被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象；换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。深拷贝：被复制对象的所有...
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":...
Java 深拷贝和浅拷贝
09-05
深拷贝和浅拷贝是在Java中用于复制对象的两种不同方式。...需要注意的是，浅拷贝和深拷贝都只适用于可变对象，对于不可变对象来说，无论是浅拷贝还是深拷贝都没有意义，因为不可变对象无法被修改。
Java的浅拷贝与深拷贝
weixin_43342036的博客
08-29 93
1.基本类型与引用类型 基本类型：基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。 引用类型：包括类、接口、数组、枚举等。 Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。 2.浅拷贝 浅拷贝实现很简单，只要让需要拷贝的类实现Cloneable接口并重写clone方法即可。浅拷贝中只是将基本类型复制到栈空
Java基础|对象克隆深浅拷贝你真的搞懂了吗？
不甩锅的码农
06-16 1300
Object 的 clone 方法是为什么是 protected 修饰？什么时候需要用到 clone 方法？浅拷贝、深拷贝区别是什么？如何实现？
Java代码实现—深拷贝与浅拷贝
weixin_44580000的博客
05-27 2517
1
java 如何实现深拷贝
热门推荐
qq_34748010的博客
05-22 1万+
1、什么叫Java浅拷贝？  浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。 2、什么叫Java深拷贝？  深拷贝复制变量值，对于引用数据，则递归至基本类型后，再复制。深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。深拷贝相比于浅拷贝速度较慢并且花销较大。 3、Java浅拷贝和
java中的浅拷贝（浅复制）和深拷贝（深复制）
大鹏
05-24 1万+
浅拷贝： 浅拷贝又称为浅复制，浅克隆，浅拷贝是指拷贝时只拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量的值都含有与原来对象相同的值，而所有对其他对象的引用都指向原来的对象，简单地说，浅拷贝只拷贝对象不拷贝引用。 深拷贝： 深拷贝又称为深复制，深克隆，深拷贝不仅拷贝对象本身，而且还拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量（不包含那些引用其他对象的变量）的值都含有与原来对象的相同的值，那些引用其他对象的变量将指向新复制...
Java Map 深拷贝方法
FunnyWhiteCat的博客
06-30 7952
Map 深拷贝方法
Java深拷贝和浅拷贝Map对象
赵广陆
01-29 4738
目录 1 将Map深拷贝到另一个Map对象当中 2 浅拷贝Map 1 将Map深拷贝到另一个Map对象当中 今天赋值的时候遇到的小坑 相关文章推荐： Java克隆方式避免频繁创建对象优化方案 https://blog.csdn.net/ZGL_cyy/article/details/126556907 1.需求说明 将一个MapA对象中所有的键值对完全拷贝到另一个MapB对象中； 另一个MapB对象中原来的键值保持不变（不受影响）； 拷贝成功后MapB对象当中的内容将不再随着MapA中内容的变化而
Java实现Map深拷贝
qinghuidu的博客
05-13 8732
开题 Map进行复制时候，会涉及到两种场景 1、map中不包含对象 2、map中包含对象 1、map中不包含对象 @Test public void putAllTest1() throws InterruptedException { Map<String, Object> goods = new LinkedHashMap<>(); goods.put("name", "可口可乐"); goods.put.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值