java浅拷贝和深拷贝的区别？？？

最新推荐文章于 2022-10-27 09:55:16 发布
最新推荐文章于 2022-10-27 09:55:16 发布
阅读量206 收藏
点赞数 3
分类专栏： 面试准备题 文章标签： java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44432069/article/details/113655205
版权

java浅拷贝和深拷贝的区别？？？

  • 假设创建一个对象A然后在将A对象赋值给B、此时你操作了B对象等同于你操作了A对象、原因就是因为他们的内存地址指向的是同一块区域、可以叫做引用的拷贝

    User user1 = new User();
User user2 = user1;

// 输出结果
user1地址：demo4.User@7f31245a
user2地址：demo4.User@7f31245a

  • 注意点：

  • public class User implements Cloneable{   // 实现Cloneable接口

  @Override   // 从写Object类中的clone()方法
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();  // 主要还是调用Object类中的clone()方法
  }
}

  • 拷贝的共同目的就是为了拷贝一个全新的对象、

浅拷贝(Shallow Copy)

浅拷贝(Shallow Copy)

案例：

Hobby类

public class Hobby{
    private String hobbyName;

    public Hobby() {
    }
    public Hobby(String hobbyName) {
        this.hobbyName = hobbyName;
    }

    public String getHobbyName() {
        return hobbyName;
    }

    public void setHobbyName(String hobbyName) {
        this.hobbyName = hobbyName;
    }

    public String toAddress() {
        return super.toString();
    }


    @Override
    public String toString() {
        return "ID{" +
                "hobbyName=" + hobbyName +
                '}';
    }
}

User类

public class User implements Cloneable{
    private String name;
    private Integer age;
    private Hobby hobby;

    public User() {
    }

    public User(String name, Integer age, Hobby id) {
        this.name = name;
        this.age = age;
        this.hobby = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Hobby getHobby() {
        return hobby;
    }

    public void setHobby(Hobby hobby) {
        this.hobby = hobby;
    }

    public String toAddress() {
        return super.toString();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", Hobby=" + hobby +
                '}';
    }
		// 从写clone方法()
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

测试类

public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Hobby hobby = new Hobby("唱歌");
        User user1 = new User("小明",18,hobby);
        User user2 = (User) user1.clone();
        System.out.println("============初始内容==========");
        System.out.println("user1地址："+user1.toAddress()+"\t\tuser2地址："+user2.toAddress());
        System.out.println("user1的Hobby地址："+user1.getHobby().toAddress()+"\t\t" +
                "user2的Hobby地址："+user2.getHobby().toAddress());
        System.out.println("user1："+user1.toString());
        System.out.println("user2："+user2.toString());
        user2.setName("小红");
        user2.setAge(17);
        hobby.setHobbyName("跳舞");
        user2.setHobby(hobby);
        System.out.println("============值赋完内容==========");
        System.out.println("user1的Hobby地址："+user1.getHobby().toAddress()+"\t\t" +
                "user2的Hobby地址："+user2.getHobby().toAddress());
        System.out.println("user1的Hobby地址："+user1.toString());
        System.out.println("user2的Hobby地址："+user2.toString());

    }
}

测试结果：

============初始内容==========
user1地址：demo4.User@7f31245a		user2地址：demo4.User@6d6f6e28
user1的Hobby地址：demo4.Hobby@135fbaa4		user2的Hobby地址：demo4.Hobby@135fbaa4
user1：User{name='小明', age=18, Hobby=ID{hobbyName=唱歌}}
user2：User{name='小明', age=18, Hobby=ID{hobbyName=唱歌}}
============值赋完内容==========
user1的Hobby地址：demo4.Hobby@135fbaa4		user2的Hobby地址：demo4.Hobby@135fbaa4
user1的Hobby地址：User{name='小明', age=18, Hobby=ID{hobbyName=跳舞}}
user2的Hobby地址：User{name='小红', age=17, Hobby=ID{hobbyName=跳舞}}

个人小结：

  • 浅拷贝简单来说就是将一个对象new了两次、但是和浅拷贝性质不一样、浅拷贝实际意义是将上一个对象拷贝一份、将其对象数据拷贝到新地址中、而最后达到两个对象的引用地址不一样。
  • 浅拷贝的特点
    • 对应基本数据类型的成员变量： 基础类型的拷贝，其中一个对象修改该值，不会影响另外一个、原因是 因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象 。
    • 对应引用类型的成员变量：比如数组或者类对象、改变其中一个，会对另外一个也产生影响 、原因是因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。

弊端：浅拷贝只对本身要拷贝的对象作为拷贝、而不会将拷贝对象中的引用类型属性再次进行拷贝。

深拷贝 (Deep Copy)

深拷贝 (Deep Copy)

案例：

Hobby类

public class Hobby implements Cloneable{
    private String hobbyName;

    public Hobby() {
    }
    public Hobby(String hobbyName) {
        this.hobbyName = hobbyName;
    }

    public String getHobbyName() {
        return hobbyName;
    }

    public void setHobbyName(String hobbyName) {
        this.hobbyName = hobbyName;
    }

    public String toAddress() {
        return super.toString();
    }


    @Override
    public String toString() {
        return "ID{" +
                "hobbyName=" + hobbyName +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

User类

public class User implements Cloneable{
    private String name;
    private Integer age;
    private Hobby hobby;

    public User() {
    }

    public User(String name, Integer age, Hobby id) {
        this.name = name;
        this.age = age;
        this.hobby = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Hobby getHobby() {
        return hobby;
    }

    public void setHobby(Hobby hobby) {
        this.hobby = hobby;
    }

    public String toAddress() {
        return super.toString();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", Hobby=" + hobby +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        hobby = (Hobby)getHobby().clone();
        return user;
    }
}

测试类

public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Hobby hobby = new Hobby("唱歌");
        User user1 = new User("小明",18,hobby);
        User user2 = (User) user1.clone();
        System.out.println("============初始内容==========");
        System.out.println("user1地址："+user1.toAddress()+"\t\tuser2地址："+user2.toAddress());
        System.out.println("user1的Hobby地址："+user1.getHobby().toAddress()+"\t\t" +
                "user2的Hobby地址："+user2.getHobby().toAddress());
        System.out.println("user1："+user1.toString());
        System.out.println("user2："+user2.toString());
        user2.setName("小红");
        user2.setAge(17);
        hobby.setHobbyName("跳舞");
        user2.setHobby(hobby);
        System.out.println("============值赋完内容==========");
        System.out.println("user1的Hobby地址："+user1.getHobby().toAddress()+"\t\t" +
                "user2的Hobby地址："+user2.getHobby().toAddress());
        System.out.println("user1的Hobby地址："+user1.toString());
        System.out.println("user2的Hobby地址："+user2.toString());

    }
}

测试结果

============初始内容==========
user1地址：demo4.User@7f31245a		user2地址：demo4.User@6d6f6e28
user1的Hobby地址：demo4.Hobby@135fbaa4		user2的Hobby地址：demo4.Hobby@45ee12a7
user1：User{name='小明', age=18, Hobby=ID{hobbyName=唱歌}}
user2：User{name='小明', age=18, Hobby=ID{hobbyName=唱歌}}
============值赋完内容==========
user1的Hobby地址：demo4.Hobby@135fbaa4		user2的Hobby地址：demo4.Hobby@45ee12a7
user1的Hobby地址：User{name='小明', age=18, Hobby=ID{hobbyName=唱歌}}
user2的Hobby地址：User{name='小红', age=17, Hobby=ID{hobbyName=跳舞}}

个人小结：

  • 深拷贝除了拷贝对象本身、对象内部的属性引用也会进行拷贝、唯一麻烦的就是在对象内部的属性的对象要去实现Cloneable接口、还要从写clone()方法、而本身对象的clone()方法中要对属性引用对象调用clone()方法将其赋值给这个引用对象属性
  • 深拷贝的特点
    • 对应基本数据类型的成员变量： 基础类型的拷贝，其中一个对象修改该值，不会影响另外一个、原因是 因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象 。(和浅拷贝一样)
    • 对应引用类型的成员变量：比如数组或者类对象、改变其中一个， 不会对另外一个也产生影响 、原因是因为深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间 。
  • 弊端
    • 如有对象属性是一个对象、就非常麻烦、需要每个对象实现Cloneable接口、并从写clone()方法、并在上一个对象的clone()方法中去调用属性对象的clone()将其拷贝后赋值给属性。
    • 深拷贝的开销大

浅拷贝和深拷贝总结

  • 不管还是浅拷贝还是深拷贝、它们两的作用就是复制对象、复制后的对象和被复制的对象引用地址不一样、可以简单理解为将复制的对象放在一个新的内存区域中。
  • 浅拷贝可以复制对象的基本类型和引用类型、只不过引用类型指向的是同一片内存空间
  • 深拷贝可以复制对象的基本类型和引用类型、只不过引用类型指向的不是同一片内存空间

参考: https://www.jianshu.com/p/94dbef2de298

采用序列化对象的形式来实现深度克隆

什么是序列化、序列化就是将内存中的对象保存在硬盘中、当做一个文件、然后将文件读取出来变成内存中的对象、这个形式是反序列化。

@Test
    public void fun_5() throws Exception {
        /**
         *  注意：
         *      User对象需要实现Serializable接口
         */
        Hobby hobby = new Hobby();
        User user1 = new User("小明",18,hobby);  // 创建新对象
        String projectPath = System.getProperty("user.dir");  // 获取当前项目路径
        System.out.println(projectPath);
        File f = new File(projectPath+"/obj.txt"); // 文件报存的本地地址
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f)); // 输出流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));// 输入流

        oos.writeObject(user1);  // 将对象序列化

        User user2 = (User) ois.readObject();// 将对象反序列化

        System.out.println("user1地址："+user1.toAddress()+"\t\tuser2地址："+user2.toAddress());
        System.out.println("user1的Hobby地址："+user1.getHobby().toAddress()+"\t\t" +
                "user2的Hobby地址："+user2.getHobby().toAddress());

        ois.close(); // 释放资源
        oos.close(); // 释放资源

}

对象(反)序列化、要实现Serializable接口、否则会报一个错误

java.io.NotSerializableException: pojo.User

·测试结果

user1地址：demo4.User@5fdef03a		user2地址：demo4.User@2c13da15
user1的Hobby地址：demo4.Hobby@5ccd43c2		user2的Hobby地址：demo4.Hobby@77556fd

具体了解还请自行测试。

小小白努力中
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
浅析Java中的深拷贝与浅拷贝
04-24
首先我们看看浅拷贝和深拷贝的定义 浅拷贝：只复制一个对象，对象内部存在的指向其他对象数组或者引用则不复制 深拷贝：对象，对象内部的引用均复制 为了更好的理解它们的区别我们假设有一个对象A，它包含有2对象对象A1和对象A2
Java浅拷贝与深拷贝
L_explorer的博客
12-30 659
Java中组合与聚合是非常重要的两个内容，本文主要来解释与区别两者。 概念 组合： 顾名思义，就是使用多个已有的对象组合为一个功能更加复杂强大的新对象。体现的是整体与部分、拥有的关系。又因为在对象之间，各自的内部细节是不可见的，所以我们也说这种方式的代码复用是黑盒式代码复用。 聚合： ...
Java中浅拷贝与深拷贝的区别
聂亚兵的博客
07-28 419
Java中浅拷贝与深拷贝的区别         今天在在学习java中，看到了clone（）方法，查看一些资料，以及自己探索了一些关于浅克隆（shadow）与深克隆（deep clone）之间的关系，就此来发表一些我自己的看法。  浅拷贝：       首先，浅拷贝实际上就是在拷贝成员变量的时候，只拷贝了基本数据类型和String数据类型。因为String数据类型是一种特殊的引用类型，JD
Java中浅拷贝和深拷贝的区别
BlueProtocolBlog
10-27 1816
被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性引用仍然指向原来的属性所指向的内存地址。需要注意的是cloneObj == obj 返回的是false，所以使用的Object的clone（）是浅拷贝。：被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性的引用都指向新的克隆出来的属性的内存地址。深拷贝的实现方式一般有三种，第一种是使用构造器来实现，这个先不说。
Java中浅拷贝与深拷贝之间的区别
allway2的博客
02-07 362
在深入探讨Java中浅表副本与深表副本之间的差异之前，让我们看看首先进行克隆的是什么。 什么是克隆？ 克隆是在内存中创建现有对象的精确副本的过程。在Java中，java.lang.Object类的clone（）方法用于克隆过程。此方法创建一个对象的精确副本，并通过逐字段分配在其上对其进行调用，并返回该对象的引用。并非Java中的所有对象都适用于克隆过程。实现Cloneable接口的对象仅适用于克隆过程。可克隆接口是标记器接口，用于为克隆过程提供标记。单击此处以查看有关Java中clon...
java深入理解浅拷贝和深拷贝
12-21
本文将会深入的探讨一下在拷贝对象中会出现的浅拷贝和深拷贝的情况。 拷贝接口 java中所有的对象都是继承自java.lang.Object。Object对象中提供了一个clone方法，来供我们对java对象进行拷贝。 protected native ...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
主要介绍了Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍,需要的朋友可以参考下
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
今天小编就为大家分享一篇关于Java Clone深拷贝与浅拷贝的两种实现方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java中的深拷贝和浅拷贝介绍
09-03
对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要...Java中有三种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)、延迟拷贝(Lazy Copy)
Java 细数浅拷贝和深拷贝
最新发布
02-27
Java 对象拷贝是为对象赋值的一种方式，简单来说就是创建一个和原对象相同的对象，新创建的对象是原对象的一个`副本`，面试官贼拉喜欢在面试的时候问一问你浅拷贝和深拷贝的原理。因为它涉及到对象的引用关系，涉及...
探讨Java中浅拷贝与深拷贝的区别
weixin_48627356的博客
10-22 202
文章目录前言一、clone()二、浅拷贝三、深拷贝四、clone()的替换方案 前言 一、clone() clone()是Object的protected方法，它不是public的，一个类不显式去重写clone()，其它类就不能直接去调用该类实例的clone()方法。 举例说明： public class CloneExample { private int i; private int j; // 构造器 public CloneExample() { } } CloneExamp..
java中浅拷贝和深拷贝_Java中浅拷贝和深拷贝的区别
weixin_35651578的博客
02-25 67
浅拷贝和深拷贝的定义：浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。深拷贝：深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象...
Java深拷贝和浅拷贝的区别（转载）
hanzuaoxue的博客
09-24 167
Object 类的 clone方法执行特定的克隆操作。 首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。(注意：所有的数组都被视为实现接口 Cloneable)否则，此方法会创建此对象的类的一个新实例，并像通过分配，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。所以，此方法执行的是该对象的“...
面试——java——深拷贝和浅拷贝
weixin_44475386的博客
12-15 331
一、浅拷贝 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。 == 浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。== 比如说，两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。 二、深拷贝 深拷贝是一个整个独立的对象拷
13、Java中的浅拷贝与深拷贝的区别。
JingLisen的博客
02-26 485
小景哥哥博客 Java中的浅拷贝与深拷贝的区别。 浅拷贝：被拷贝的对象所有的变量都含有与原来对象相同的值，而所有对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅拷贝所考虑的对象，而没拷贝它所引用的对象。 深拷贝：被复制的对象所有变量都含有与原来对象相同的值，而那些引用其他的对象的变量将指向被拷贝的新对象，深拷贝把拷贝对象的引用也拷贝了。 当类中只有一些基本数据类型时，只需clone一下即可。但当类中包含一些对象时，就需要深拷贝了，实现方式是在对对象调用clone方法完成拷贝之后，接着对对象中的非基本类
java中浅拷贝和深拷贝的区别
wuxinliulei的专栏
04-01 1111
所谓的浅克隆，顾名思义就是很表面的很表层的克隆，如果我们要克隆Administrator对象，只克隆他自身以及他包含的所有对象的引用地址。 而深克隆，就是非浅克隆。克隆除自身以外所有的对象，包括自身所包含的所有对象实例。至于深克隆的层次，由具体的需求决定，也有“N层克隆”一说。 但是，无论所有的基本（primitive）类型数据是浅克隆还是深克隆，都会进行原值克隆。毕竟他们都不是对象，不是存储
Java中的浅拷贝与深拷贝
K.Sun
06-09 272
先说明一下啥是浅拷贝，啥是深拷贝。浅拷贝就是拷贝完以后实际上在内存中还是一个对象。 深拷贝拷贝完以后就是两个独立的对象了。在代码上是怎么体现的呢？我们知道用==来判断，如果两个对象比较返回true，那这两个家伙是绝对相等的，注意这里的绝对，谁和它绝对相等啊，那就是它自己嘛？这个有点上升到哲学的观点了哈。如果拷贝还是绝对相等的，那就是浅拷贝。如果返回false，那这个就可能的原因多了，你可能从外表看
Java中的深拷贝(深复制)和浅拷贝(浅复制)
weixin_34249678的博客
12-14 279
深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念，尤其在C++语言中，若不弄懂，则会在delete的时候出问题，但是我们在这幸好用的是Java。虽然java自动管理对象的回收，但对于深拷贝(深复制)和浅拷贝(浅复制)，我们还是要给予足够的重视，因为有时这两个概念往往会给我们带来不小的困惑。 浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷...
java深拷贝和浅拷贝_Java深拷贝和浅拷贝的区别
weixin_29958569的博客
02-16 361
浅拷贝被复制的对象的所有的变量都与原对象有相同的值，而所有的引用对象仍然指向原来的对象。换言之，浅拷贝 不复制引用对象。1 class Experience {2 private String skill;3 public void setSkill(String skill){4 this.skill = skill;5 }6 public voi...
java深拷贝和浅拷贝的区别是什么?
09-05
深拷贝和浅拷贝是在对象复制过程中的两种不同方式。 浅拷贝是创建一个新对象，然后将源对象的非静态字段的值复制到新对象中。如果字段是基本数据类型，拷贝的是值本身；如果字段是引用类型，拷贝的是引用地址，即新...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值