精华内容
下载资源
问答
  • @Data public class Student implements Cloneable { String subj; String name; @Override public Object clone() { Student stu =(Student)super.clone(); return stu;... //深拷贝
    	@Data
    	public class Student implements Cloneable { 
    		String subj; 
    		String name; 
    	    @Override  
    		public Object clone() {  
    		    Student stu =(Student)super.clone();  
    		    return stu;  
    		}  
    	}
    	...
    	Student stu1 = new Student({"chinese","ming"});
    	Student stu2 = (Student) stu1.clone();	//深拷贝
    
    展开全文
  • 标题直接引入话题,接下来就说说,什么是浅拷贝,和深拷贝吧 1,浅拷贝和深拷贝 2,浅拷贝和深拷贝的区别 浅拷贝: 将原对象或原数组的引用直接赋给新对象,新数组,新对象/数组只是原对象的一个引用 深拷贝...
    标题直接引入话题,接下来就说说,什么是浅拷贝,和深拷贝吧
    

    1,浅拷贝和深拷贝

    在这里插入图片描述

    2,浅拷贝和深拷贝的区别

    1. 浅拷贝: 将原对象或原数组的引用直接赋给新对象,新数组,新对象/数组只是原对象的一个引用

    2. 深拷贝: 创建一个新的对象和数组,将原对象的各项属性的“值”(数组的所有元素)拷贝过来,是“值”而不是“引用”

    3,为什么要使用深拷贝?

    • 我们希望在改变新的数组(对象)的时候,不改变原数组(对象)

    4 ,手敲深拷贝

    • 不仅拷贝第一层级,还能够拷贝数组或对象所有层级的各项值

    • 不是单独针对数组或对象,而是能够通用于数组,对象和其他复杂的JSON形式的对象

    • ##使用变量.JSON.parse(JSON.stringify(变量)

    var array = [
        { number: 1 },
        { number: 2 },
        { number: 3 }
    ];
    var copyArray = JSON.parse(JSON.stringify(array))
    copyArray[0].number = 100;
    console.log(array); //  [{number: 1}, { number: 2 }, { number: 3 }]
    console.log(copyArray); // [{number: 100}, { number: 2 }, { number: 3 }]
    
    • 递归技术高端方法
    var array = [
       { number: 1 },
       { number: 2 },
       { number: 3 }
    ];
    function copy (obj) {
            var newobj = obj.constructor === Array ? [] : {};
            if(typeof obj !== 'object'){
                return;
            }
            for(var i in obj){
               newobj[i] = typeof obj[i] === 'object' ?
               copy(obj[i]) : obj[i];
            }
            return newobj
    }
    var copyArray = copy(array)
    copyArray[0].number = 100;
    console.log(array); //  [{number: 1}, { number: 2 }, { number: 3 }]
    console.log(copyArray); // [{number: 100}, { number: 2 }, { number: 3 }]
    
    展开全文
  • 深拷贝和浅拷贝区别: 浅拷贝(shallow copy):只复制指向某个对象的指针,而不复制对象本身,新旧对象共享一块内存;   深拷贝(deep copy):复制并创建一个一摸一样的对象,不共享内存,修改新对象,旧对象保持...

    深拷贝和浅拷贝区别:
    浅拷贝(shallow copy):只复制指向某个对象的指针,而不复制对象本身,新旧对象共享一块内存;
    深拷贝(deep copy):复制并创建一个一摸一样的对象,不共享内存,修改新对象,旧对象保持不变。

    深拷贝:
    Object.assign(前端设置的值,后端传入的值)

    有时候前端会创建一个对象,并设置默认值

    qian:{
        a:"aaa",
        b:"bbb",
        c:"ccc"
    }
    

    后端传入一个对象,但往往属性是不完整的,如下

    hou:{
        a:"111",
        b:"222"
    }
    

    如果直接赋值:

    qian=hou
    

    那么
    qian就会变成和后一样,相当于下面

    qian:{
        a:"111",
        b:"222"
    }
    

    你会发现少了属性c,因为qian的引用地址变成了hou,他们共用了同一个地址,但是前端只想改变a,b的值,c的值保留,这时候就需要用到深拷贝了

    Object.assign(qian,hou)
    

    这样qian的值就相当于变成

    qian:{
        a:"111",
        b:"222",
        c:"ccc"
    }
    
    展开全文
  • Java深入理解深拷贝和浅拷贝区别

    万次阅读 多人点赞 2019-02-13 23:31:47
    一、拷贝的引入 (1)、引用拷贝 创建一个指向对象的引用变量的拷贝。 Teacher teacher = new Teacher("Taylor",26); Teacher otherteacher = teacher; System.out.println(teacher); System.out.println...

    欢迎大家关注我的公众号【老周聊架构】,Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

    一、拷贝的引入

    (1)、引用拷贝

    创建一个指向对象的引用变量的拷贝。

    public class QuoteCopy {
        public static void main(String[] args) {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = teacher;
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = 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;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@28a418fc
    

    结果分析:由输出结果可以看出,它们的地址值是相同的,那么它们肯定是同一个对象。teacherotherTeacher只是引用而已,他们都指向了一个相同的对象Teacher(“riemann”,28)。 这就叫做引用拷贝

    在这里插入图片描述

    (2)、对象拷贝

    创建对象本身的一个副本。

    public class ObjectCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher("riemann", 28);
            Teacher otherTeacher = (Teacher) teacher.clone();
            System.out.println(teacher);
            System.out.println(otherTeacher);
        }
    }
    
    class Teacher implements Cloneable {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = 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 Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    com.test.Teacher@28a418fc
    com.test.Teacher@5305068a
    

    结果分析:由输出结果可以看出,它们的地址是不同的,也就是说创建了新的对象, 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

    在这里插入图片描述

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

    二、浅拷贝

    (1)、定义

    被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝,但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

    简而言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象。

    (2)、浅拷贝实例

    public class ShallowCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
    
        }
    }
    
    class Teacher 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;
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        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 Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            Object object = super.clone();
            return object;
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: jack
    

    结果分析: 两个引用student1student2指向不同的两个对象,但是两个引用student1student2中的两个teacher引用指向的是同一个对象,所以说明是浅拷贝

    在这里插入图片描述

    三、深拷贝

    (1)、定义

    深拷贝是一个整个独立的对象拷贝,深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

    简而言之,深拷贝把要复制的对象所引用的对象都复制了一遍。

    (2)、深拷贝实例

    public class DeepCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher();
            teacher.setName("riemann");
            teacher.setAge(28);
    
            Student student1 = new Student();
            student1.setName("edgar");
            student1.setAge(18);
            student1.setTeacher(teacher);
    
            Student student2 = (Student) student1.clone();
            System.out.println("-------------拷贝后-------------");
            System.out.println(student2.getName());
            System.out.println(student2.getAge());
            System.out.println(student2.getTeacher().getName());
            System.out.println(student2.getTeacher().getAge());
    
            System.out.println("-------------修改老师的信息后-------------");
            // 修改老师的信息
            teacher.setName("jack");
            System.out.println("student1的teacher为: " + student1.getTeacher().getName());
            System.out.println("student2的teacher为: " + student2.getTeacher().getName());
        }
    }
    
    class Teacher 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 Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Student implements Cloneable {
        private String name;
        private int age;
        private Teacher teacher;
    
        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 Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    
        public Object clone() throws CloneNotSupportedException {
            // 浅复制时:
            // Object object = super.clone();
            // return object;
    
            // 改为深复制:
            Student student = (Student) super.clone();
            // 本来是浅复制,现在将Teacher对象复制一份并重新set进来
            student.setTeacher((Teacher) student.getTeacher().clone());
            return student;
    
        }
    }
    

    输出结果:

    -------------拷贝后-------------
    edgar
    18
    riemann
    28
    -------------修改老师的信息后-------------
    student1的teacher为: jack
    student2的teacher为: riemann
    

    结果分析:
    两个引用student1student2指向不同的两个对象,两个引用student1student2中的两个teacher引用指向的是两个对象,但对teacher对象的修改只能影响student1对象,所以说是深拷贝

    在这里插入图片描述

    展开全文
  • Java 深拷贝的使用

    2021-08-28 14:40:06
    Cloneable 接口实现深拷贝2. 浅拷贝引发的问题2.1 fastjson 对象转化成 json 字符串出现 $ref2.2 多线程环境下的数据问题 前言 深拷贝是相对于浅拷贝而言的,二者的主要区别如下,在多线程和并发的场景中经常会涉及...
  • 也许我们都了解javascript中的基础类型有哪些:原始数据类型(Undefined、...这种情况怎么解决呢,当然是深拷贝了。可以通过下面的图了解下深浅拷贝的区别。 console.log(oldObj == newObj);//true,说明指向了同一个
  • 目录浅拷贝介绍深拷贝介绍拷贝的工具类推荐 浅拷贝介绍 拷贝出当前对象的一个副本,这个新对象和当前对象处于不同的堆内存中,两个对象的基本数据类型的值完全一样,但是引用数据类型还是指向同一个对象的。 深拷贝...
  • 快速上手 深拷贝(clone)、浅拷贝 及(protected的使用) 简易理解: 浅拷贝:只拷贝源对象的地址,所以源对象的任何值变化,拷贝对象值也随着变化。 深拷贝:拷贝对象的值,而不是地址,当源对象的值发生变化,...
  • 深拷贝与浅拷贝

    2020-12-28 14:31:26
    深拷贝和浅拷贝最根本的区别在于是否获取一个独立的复制体。 假设B复制了A,修改A的时候,看B是否发生变化: 如果B跟着也变了,说明是浅拷贝, 如果B没有改变,说明是深拷贝; 因为: 浅拷贝(shallowCopy)得到的...
  • 作为一名前端开发工程师,在平时的工作开发中,项目中有时候肯定会遇到存储、解析后端传递过来的相关数据的,那么不可避免的肯定会用到深拷贝、以及浅拷贝的相关知识,哪怕是在面试过程中都会遇到这么一道看似简单的...
  • 有关JS深拷贝

    2020-03-23 15:47:22
    ) 深拷贝这个东西,相信很多前端的小伙伴都有了解,而且这个问题是面试中常问的问题,经常让我们手写的题目。接下来就分享下两种鄙人开发时常用到的两种深拷贝的方法。 //简短粗暴 JSON.parse JSON.stringify //要...
  • 实现浅拷贝和深拷贝+

    2020-09-04 18:22:58
    在日常开发中,如果只是对后端返回数据进行深拷贝,JSON.parse(JSON.stringify())就可以。在写一些功能性的方法时,该方法就不能用了,它无法拷贝含有函数和正则的object对象,因为该方法会把函数和正则变成null。...
  • 在一个项目中有用到d3.js画力导向图,用从后端获取到的同一个数据画出两个不同的力导向图(乱序版和分上下游企业版本),但奇怪的是,虽然变量什么的都设置的不同的名称...深拷贝代码如下(拷贝对象数组): var objDeep
  • 深拷贝和浅拷贝

    2021-02-22 19:25:47
    在我自己学习的时候,往往会忽略一些数据结构上比较深层次的内容,就比如今天的主题深拷贝和浅拷贝,我一直觉得没有啥用,还占用我的学习时间,直到今天用到的时候,百思不得其解的时候,才发现自己的以前的学习是有...
  • JavaScript 实现深拷贝

    2017-04-20 23:48:23
    JavaScript 实现深拷贝 2014-08-27 17:27:56 分类: JavaScript  写该系列的起因是在网上遇到一套比较不错的应试题目,涉及到了前端的各个角落,以及模块化,HTTP,后端等。题目在此 前端题目  第一题,就来...
  • JS数组的深拷贝和浅拷贝

    千次阅读 2018-07-10 19:21:24
    一、浅拷贝在js中操作数组过程中,会需要把数组进行备份,直接赋值如下://浅拷贝 直接赋值吧 var arr1 = ["前端","安卓","苹果"]; var arr2 = arr1; arr2[0] = "后端"; ...
  • Python 深拷贝和浅拷贝 Python 中,将对象进行赋值的方式共有三种: 直接赋值:直接将对象的引用赋值给等号左边的对象。 浅拷贝:复制一份父对象,但不会复制父对象内部子对象。 深拷贝:既复制父对象,也复制子...
  • 对象拷贝在我们日常写代码的时候基本上是刚性需求,经常遇到,只不过很多人天天忙于写业务,忽视了一些细节问题和理解,有时候...这两个概念的区分,对于、浅拷贝问题的理解非常重要。 正如Java圣经《Java编程思想..
  • C++ 构造函数,委托构造函数,深拷贝,浅拷贝
  • JS对象的浅拷贝和深拷贝一、值类型和引用类型1、js数据类型2、引用拷贝二、浅拷贝1、循环拷贝(for of)2、spread运算符(...)3、object.assign()方法三、深拷贝1、JSON方法2、递归循环四、浅拷贝和深拷贝的应用1、...
  • JSON.parse(JSON.stringify(obj))我们一般用来深拷贝,其过程说白了 就是利用JSON.stringify 将js对象序列化(JSON字符串),再使用JSON.parse来反序列化(还原)js对象;序列化的作用是存储(对象本身存储的只是一个...
  • 一 赋值、浅拷贝、深拷贝 1 赋值 对象之间赋值本质上 是对象之间的引用传递而已。也就是多个对象指向同一个数据空间。 2 浅拷贝 浅拷贝是对一个对象的顶层数据的拷贝 说明: 如果 如图,C对象的顶层数据就是[a,b]...
  • 1.什么是引用拷贝?使用引用拷贝会出现什么问题? 在java中我们常常会用到拷贝,如以下的形式 引用拷贝: Person person = new Person(); Person copyPerson = person;...对象拷贝分为浅拷贝和深拷贝 2.1浅拷贝 话不多说
  • 面试的时候,经常会问深拷贝与浅拷贝的问题。因为它可以考察一个人的很多方面,比如基本功,逻辑能力,编码能力等等。 另外在实际工作中,也常会遇到它。比如用于页面展示的数据状态,与需要传给后端的数据包中,有...
  • Java 浅拷贝和深拷贝

    2020-12-09 10:54:50
    深拷贝 (Deep Copy) 1. 浅拷贝介绍 浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值;如果属性是内存地址(引用类型),拷贝...
  • Java深拷贝和浅拷贝

    2019-02-28 15:56:30
    转载: ...浅拷贝是指在拷贝对象时,对于基本数据类型的变量会重新复制一份,而对于引用...而深拷贝是指在拷贝对象时,同时会对引用指向的对象进行拷贝。 区别就在于是否对 对象中的引用变量所指向的对象进行拷贝。 ...
  • 深拷贝的那些事

    2020-05-19 21:14:29
    关于JSON.parse与JSON.stringify深拷贝的坑 JSON.parse(JSON.stringify(obj))我们一般用来深拷贝,其过程说白了 就是利用JSON.stringify 将js对象序列化(JSON字符串),再使用JSON.parse来反序列化(还原)js对象;...
  • 浅拷贝与深拷贝问题

    2021-03-21 09:16:39
    6-4 浅拷贝与深拷贝问题 (10 分) Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性(成员变量)拷贝到另一个有着相同类类型的对象中去。举例说明:比如,对象A和对象B都属于类S,具有属性a和b。那么对对象A...
  • JS-Object深拷贝与浅拷贝 Javascript中的数据类型分为两大类: 基本类型、引用类型 基本类型:String、Number、Boolean、Null、Undefined 引用类型:Object 常用的几种拷贝Object的方法 Object.assign() 适合拷贝...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,011
精华内容 4,404
关键字:

后端的深拷贝