精华内容
下载资源
问答
  • 主要介绍了DOM节点深度克隆函数cloneNode()用法,实例分析了cloneNode()函数深度复制的操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了JS对象深度克隆,结合实例形式分析了JavaScript对象深度克隆的实现方法与相关注意事项,需要的朋友可以参考下
  • 本篇文章是对JAVA深度克隆与浅度克隆的区别进行了详细的分析介绍,需要的朋友参考下
  • 主要介绍了JS对象的深度克隆方法,结合实例形式分析了JavaScript深度克隆的实现技巧,需要的朋友可以参考下
  • 本篇文章是对JAVA对象深度克隆进行了详细的分析介绍,需要的朋友参考下
  • beancopy ###java bean深度克隆的简单实现 Bean中必须有对应的getter, setter方法. 可以复制包含 "8种基本类型, String, java.util.Date, enum, Set, List 以及多层嵌套" 的Bean.
  • 本文档是解决 引用问题的解决方案,它不仅可以解决引用值拷贝 ,还可以原样复制一个一摸一样的数组、对象包括其中的方法。
  • 如何深度克隆一个对象在我们日常工作中经常会遇到需要去克隆一个对象比如多个地方用到的公共的图表基本参数的配置相信很多人会想到用 Object.assign, JSON.stringify 和 JSON.parse 方法去克隆一个对象,这个可以...

    如何深度克隆一个对象在我们日常工作中经常会遇到需要去克隆一个对象比如多个地方用到的公共的图表基本参数的配置

    相信很多人会想到用 Object.assign, JSON.stringify 和 JSON.parse 方法去克隆一个对象,这个可以明确告诉大家这些都是些不靠谱的浅度克隆。

    我们先来试一下 Object.assign 在控制台执行下列操作

    d5a8e4744f1913bde8d21be770679310.png

    接下来我们看下 JSON.stringify 和 JSON.parse 克隆对象,同样在控制输入

    00aaf82bff6964912812ed39c3ebff28.png

    下面咋们来看一种稍微靠谱的一种方式。在本站搜的前几条中发现的。function isArray (arr) {

    return Object.prototype.toString.call(arr) === '[object Array]';

    }

    // 深度克隆

    function deepClone (obj) {

    if(typeof obj !== "object" && typeof obj !== 'function') {

    return obj; //原始类型直接返回

    }

    var o = isArray(obj) ? [] : {};

    for(i in obj) {

    if(obj.hasOwnProperty(i)){

    o[i] = typeof obj[i] === "object" ? deepClone(obj[i]) : obj[i];

    }

    }

    return o;

    }

    看是靠谱是真是假我们来验证一把 还是在控制台输入

    f109916b75f7f1ea27d39766447dfa5d.png

    大家发现什么异常的了吗?

    这个没有区分具体的对象,在此问下大家js的对象有哪些呢?相信一般人答不出来4个

    [object Object], [object Array], [object Null], [object RegExp], [object Date], [object HTMLXXElement], [object Map],[object Set],... 等等一系列

    检测类型使用 Object.prototype.toString.call(xxx) 和 typeof

    我们分析下上面对象中哪些是引用类型需要特殊处理呢?相信大家都不陌生了。[object Object] 和 [object Array]

    好!详细大家思路有了,咋们用递归来实现一把吧!const deepClone = function(obj) {

    // 先检测是不是数组和Object

    // let isMap = Object.prototype.toString.call(obj) === '[object Map];

    // let isSet = Object.prototype.toString.call(obj) === '[object Set];

    // let isArr = Object.prototype.toString.call(obj) === '[object Array]';

    let isArr = Array.isArray(obj);

    let isJson = Object.prototype.toString.call(obj) === '[object Object]';

    if (isArr) {

    // 克隆数组

    let newObj = [];

    for (let i = 0; i < obj.length; i++) {

    newObj[i] = deepClone(obj[i]);

    }

    return newObj;

    } else if (isJson) {

    // 克隆Object

    let newObj = {};

    for (let i in obj) {

    newObj[i] = deepClone(obj[i]);

    }

    return newObj;

    }

    // 不是引用类型直接返回

    return obj;

    };

    Object.prototype.deepClone = function() {

    return deepClone(this);

    };咋们先不考虑Map Set Arguments [object XXArrayBuffer] 对象了原理都是一样

    各种情况分析完了才说算是真克隆

    我们在控制台看下注意先要把方法在控制台输进去,在调试

    5a9ac63cf0a41f195aad6e74cf0a7607.png

    是不是解决了? 在此并没有结束。 专注的伙伴们相信发现了对象中包含了个 deepClone 方法,具体细节我们在此就不多说了,我们给 Object 添加了个 Object.prototype.deepClone方法导致了每个对象都有了此方法。

    原则上我们不允许在原型链上添加方法的,因为在循环中 for in, Object.entries, Object.values, Object.keys 等方法会出现自定义的方法。

    相信熟悉 Object 文档的伙伴人已经知道解决方案了,

    Object.defineProperty 这个方法给大家带来了福音 具体参考 Object 文档。我们使用一个enumerable (不可枚举)属性就可以解决了。

    在原来基础上添加以下代码即可。Object.defineProperty(Object.prototype, 'deepClone', {enumerable: false});

    在看控制台

    7dffe7cd6b95dae9143ac074327213b4.png同样上面方法中也是无法克隆一个不可枚举的属性。

    完整代码如下const deepClone = function(obj) {

    // 先检测是不是数组和Object

    // let isArr = Object.prototype.toString.call(obj) === '[object Array]';

    let isArr = Array.isArray(obj);

    let isJson = Object.prototype.toString.call(obj) === '[object Object]';

    if (isArr) {

    // 克隆数组

    let newObj = [];

    for (let i = 0; i < obj.length; i++) {

    newObj[i] = deepClone(obj[i]);

    }

    return newObj;

    } else if (isJson) {

    // 克隆Object

    let newObj = {};

    for (let i in obj) {

    newObj[i] = deepClone(obj[i]);

    }

    return newObj;

    }

    // 不是引用类型直接返回

    return obj;

    };

    Object.prototype.deepClone = function() {

    return deepClone(this);

    };

    Object.defineProperty(Object.prototype, 'deepClone', {enumerable: false});为了兼容低版本浏览器需要借助 babel-polyfill;

    最后还是推荐lodash的cloneDeep方法。

    好了,深度克隆介绍到此。

    展开全文
  • 如果需要克隆对象,一般需要先创建一个对象,然后将原对象中的数据导入到新创建的对象中去,而不用根据已有对象进行手动赋值操作。二:Object中的clone()方法protected native Object clone() throws ...

    一:使用目的:

    就是为了快速构造一个和已有对象相同的副本。如果需要克隆对象,一般需要先创建一个对象,然后将原对象中的数据导入到新创建的对象中去,而不用根据已有对象进行手动赋值操作。

    二:Object中的clone()方法

    protected native Object clone() throws CloneNotSupportedException;

    说明:1.这是一个navtive方法  2.要使用该方法必须继承Object类,因为修饰符为protected  3.返回值为Object,需要强转

    使用该方法时:x.clone()!=x为true,对于基础类型来说,在堆内存中创建了一个独立且内容与之相同的内存区域.对于引用数据类型来说,克隆对象和原始对象在java 堆(heap)中是两个独立的对  象,x.clone().getClass() == x.getClass()  他们所属的类是同一个,x.clone().equals(x)   所比较的对象内容相同

    三:深度克隆和浅度克隆

    浅度克隆:被克隆得到的对象基本类型的值修改了,原对象的值不会改变

    深度克隆:被克隆得到的对象基本类型的值修改了,原对象的值改变

    public class ShadowClone implements Cloneable {

    private int a; // 基本类型

    private int[] b; // 非基本类型

    // 重写Object.clone()方法,并把protected改为public

    @Override

    public Object clone(){

    ShadowClone sc = null;

    try

    {

    sc = (ShadowClone) super.clone();

    } catch (CloneNotSupportedException e){

    e.printStackTrace();

    }

    return sc;

    }

    public int getA()

    {

    return a;

    }

    public void setA(int a)

    {

    this.a = a;

    }

    public int[] getB() {

    return b;

    }

    public void setB(int[] b) {

    this.b = b;

    }

    }

    ShadowClone c1 = new ShadowClone();

    //对c1赋值

    c1.setA(100) ;

    c1.setB(new int[]{1000}) ;

    System.out.println("克隆前c1: a="+c1.getA()+" b="+c1.getB()[0]);

    //克隆出对象c2,并对c2的属性A,B,C进行修改

    ShadowClone c2 = (ShadowClone) c1.clone();

    //对c2进行修改

    c2.setA(50) ;

    int []a = c2.getB() ;

    a[0]=500 ;

    c2.setB(a);

    System.out.println("克隆前c1: a="+c1.getA()+" b="+c1.getB()[0]);

    System.out.println("克隆后c2: a="+c2.getA()+ " b[0]="+c2.getB()[0]);

    console:

    克隆前c1: a=100 b=1000

    克隆前c1: a=100 b=500

    克隆后c2: a=50 b[0]=500

    可见:基本类型可以使用浅克隆,而对于引用类型,由于引用的是内容相同,所以改变c2实例对象中的属性就会影响到c1。所以引用类型需要使用深克隆。另外,在开发一个不可变类的时候,如果这个不可变类中成员有引用类型,则就需要通过深克隆来达到不可变的目的。

    四:重写clone方法完成深度克隆

    class bottle implementsCloneable {publicwine wn;publicbottle(wine wn) {this.wn =wn;

    }//覆写clone()方法

    protected Object clone() throwsCloneNotSupportedException {

    bottle newBtl= (bottle) super.clone();

    newBtl.wn=(wine) wn.clone();returnnewBtl;

    }

    }class wine implementsCloneable {intdegree;public intgetDegree() {returndegree;

    }public void setDegree(intdegree) {this.degree =degree;

    }//覆写clone()方法

    protected Object clone() throwsCloneNotSupportedException {return super.clone();

    }

    }

    public static void main(String[] args) throws CloneNotSupportedException {

    bottle bottle = new bottle(new wine());

    bottle bottle1 = (bottle) bottle.clone();

    System.out.println("bottle1.wine : " + bottle1.wn.getDegree() );

    bottle1.wn.setDegree(100);

    System.out.println("bottle1.wine : " + bottle1.wn.getDegree() );

    System.out.println("bottle.wine : " + bottle.wn.getDegree());

    }

    console:

    bottle1.wine : 0bottle1.wine :100bottle.wine :0

    如果wine类中多了一个String name的属性呢?

    class wine implementsCloneable {intdegree;

    String name="法国白兰地";public intgetDegree() {returndegree;

    }public void setDegree(intdegree) {this.degree =degree;

    }publicString getName() {returnname;

    }public voidsetName(String name) {this.name =name;

    }//覆写clone()方法

    protected Object clone() throwsCloneNotSupportedException {return super.clone();

    }

    }

    class bottle implementsCloneable {publicwine wn;publicbottle(wine wn) {this.wn =wn;

    }//覆写clone()方法

    protected Object clone() throwsCloneNotSupportedException {

    bottle newBtl= (bottle) super.clone();

    newBtl.wn=(wine) wn.clone();returnnewBtl;

    }

    }

    Test

    bottle bottle = new bottle(newwine());

    bottle bottle1=(bottle) bottle.clone();

    System.out.println("bottle1.wine : " +bottle1.wn.getName() );

    bottle1.wn.setName("中国二锅头");

    System.out.println("bottle1.wine : " +bottle1.wn.getName() );

    System.out.println("bottle.wine : " + bottle.wn.getName());

    console:

    bottle1.wine : 法国白兰地

    bottle1.wine : 中国二锅头

    bottle.wine : 法国白兰地

    五:使用序列化实现深度克隆

    public class DeepPerson implementsSerializable {private inta;private int[] b;publicDeepPerson() {

    }public DeepPerson(int a, int[] b) {this.a =a;this.b =b;

    }public intgetA() {returna;

    }public void setA(inta) {this.a =a;

    }public int[] getB() {returnb;

    }public void setB(int[] b) {this.b =b;

    }

    }

    public classTest1 {public static void main(String[] args) throwsCloneNotSupportedException{

    DeepPerson dc1= newDeepPerson();//对dc1赋值

    dc1.setA(100);

    dc1.setB(new int[] { 1000});

    System.out.println("克隆前dc1: a=" + dc1.getA()+"b[0]=" + dc1.getB()[0]);

    DeepPerson dc2=(DeepPerson) deepClone(dc1);//对c2进行修改

    dc2.setA(50);int[] a =dc2.getB();

    a[0] = 500;

    System.out.println("克隆后dc1: a=" + dc1.getA()+"b[0]=" + dc1.getB()[0]);

    System.out.println("克隆后dc2: a=" + dc2.getA()+"b[0]=" + dc2.getB()[0]);

    }public staticObject deepClone(Object object){

    Object o=null;try{if (object != null){

    ByteArrayOutputStream baos= newByteArrayOutputStream();

    ObjectOutputStream oos= newObjectOutputStream(baos);

    oos.writeObject(object);

    oos.close();

    ByteArrayInputStream bais= newByteArrayInputStream(baos.toByteArray());

    ObjectInputStream ois= newObjectInputStream(bais);

    o=ois.readObject();

    ois.close();

    }

    }catch(IOException e){

    e.printStackTrace();

    }catch(ClassNotFoundException e) {

    e.printStackTrace();

    }returno;

    }

    }

    console:

    克隆前dc1: a=100b[0]=1000克隆后dc1: a=100b[0]=1000克隆后dc2: a=50b[0]=500

    六、总结:

    1.克隆方法用于创建对象的拷贝,为了使用clone方法,类必须实现java.lang.Cloneable接口重写protected方法clone,如果没有实现Clonebale接口会抛出CloneNotSupportedException.

    2.在克隆java对象的时候不会调用构造器

    3.java提供一种叫浅拷贝(shallow copy)的默认方式实现clone,创建好对象的副本后然后通过赋值拷贝内容,意味着如果你的类包含引用类型,那么原始对象和克隆都将指向相同的引用内容,这是很危险的,因为发生在可变的字段上任何改变将反应到他们所引用的共同内容上。为了避免这种情况,需要对引用的内容进行深度克隆。

    4.按照约定,实例的克隆应该通过调用super.clone()获取,这样有助克隆对象的不变性。如:clone!=original和clone.getClass()==original.getClass(),尽管这些不是必须的

    展开全文
  • 深度克隆

    2019-06-26 19:17:02
    深度克隆 对于基本数据类型,例如 string number boolean之类的没有克隆深浅的概念 对于引用数据类型,像数组和对象,就有克隆的深浅之分,浅拷贝就是拷贝之后会影响原来的数据,深拷贝(深度克隆)就是拷贝之后...

    深度克隆

    • 对于基本数据类型,例如 string number boolean之类的没有克隆深浅的概念
    • 对于引用数据类型,像数组和对象,就有克隆的深浅之分,浅拷贝就是拷贝之后会影响原来的数据,深拷贝(深度克隆)就是拷贝之后不会影响原来的数据
    浅拷贝
    const zhangsan = {
        name:"zhangsan",
        age:24,
        gender:"man"
    }
    const lisi = zhangsan
    lisi.name = "lisi"
    console.log(lisi) // { name: 'lisi', age: 24, gender: 'man' }
    console.log(zhangsan) // { name: 'lisi', age: 24, gender: 'man' }
    
    • 可以看见直接把 zhangsan 这个对象赋给 lisi 之后,当 lisi 改变 name 属性之后,zhangsan 这个对象的 name 属性也改变了,因为这两个对象是同一个地址,因此一个改变会导致另一个也会发生改变,这就是浅拷贝
    那么怎么做才可以深度拷贝呢?
    • 首先要明白为什么要使用深度拷贝?因为在处理大量数据的时候,你并不知道这些引用类型的数据哪些重要哪些不重要,为此不可以轻易的改变数据,于是深度拷贝就变得很重要了
    深度拷贝的方法
    1. json方法,即 JSON.parse(JSON.stringify(引用数据))
    const zhangsan = {
        name:"zhangsan",
        age:24,
        gender:"man"
    }
    const lisi = JSON.parse(JSON.stringify(zhangsan))
    lisi.name = "lisi"
    console.log(lisi) // { name: 'lisi', age: 24, gender: 'man' }
    console.log(zhangsan) // { name: 'zhangsan', age: 24, gender: 'man' }
    
    • 这样做之后,lisizhangsan 就没有关系了,lisi 的数据改变不会影响 zhangsan 数据的改变,这就是 深度克隆
    1. 利用对象解构
    const zhangsan = {
        name:"zhangsan",
        age:24,
        gender:"man"
    }
    const lisi = {...zhangsan}
    lisi.name = "lisi"
    console.log(lisi) // { name: 'lisi', age: 24, gender: 'man' }
    console.log(zhangsan) // { name: 'zhangsan', age: 24, gender: 'man' }
    
    • 这是 ES6 的语法了,也很简单
    1. webworker
      实际上利用 webworker 也是可以实现深度拷贝的,这只是一个实现的方式,但是不建议使用
    • index.js
    const work = new Worker("./count.js")
    class People{
        constructor(name,age,gender){
            this.name = name
            this.age = age
            this.gender = gender
        }
        sayName(){
            console.log(`My name is ${this.name}`)
        }
    }
    const peo1 = new People("zhangsan",24,"man")
    let peo2 = null
    work.postMessage(peo1)
    work.onmessage = function(event){
        peo2 = event.data
        peo2.name = "lisi"
        console.log(peo2) // { name: "lisi", age: 24, gender: "man" }
        console.log(peo1) // { name: "zhangsan", age: 24, gender: "man" }
    }
    
    • count.js
    self.onmessage = function(event){
        self.postMessage(event.data)
    }
    
    • index.html
    <!DOCTYPE html>
    <html>
        <head>
            <meta charset="utf-8">
            <title>webwork</title>
        </head>
        <body>
            <script src="./index.js"></script>
        </body>
    </html>
    

    webworker
    这个方法的原理我感觉和 json方法 有异曲同工之妙

    综上所述:
    第二种方法,也就是对象结构的方法要更加简单一点
    展开全文
  • 我们经常会遇到需要克隆一个对象,对克隆的对象操作之后不影响原有对象以及与之关联的对象Java的Object类提供了clone方法,用来进行克隆对象,不过JDK提供的clone()方法只是浅度克隆,要想深度克隆需要自己来实现,...

    在日常的开发中,我们经常会遇到需要克隆一个对象,对克隆的对象操作之后不影响原有对象以及与之关联的对象

    Java的Object类提供了clone方法,用来进行克隆对象,不过JDK提供的clone()方法只是浅度克隆,要想深度克隆需要自己来实现,那么什么是浅度克隆和深度克隆呢?

    浅度克隆

    JDK提供的克隆是浅度克隆,它只将对象中的基础数据类型的成员变量克隆到新对象中,对象中的引用类型只是克隆了一个引用,克隆后的引用类型还是指向原对象,如下图所示

    3f9bcec1a0ce1dce933be321eab61ce3.png

    代码如下:

    public 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;

    }

    }

    public class User implements Cloneable{

    private String name;

    private int age;

    private Teacher teacher;

    public User(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 Teacher getTeacher() {

    return teacher;

    }

    public void setTeacher(Teacher teacher) {

    this.teacher = teacher;

    }

    @Override

    protected User clone() throws CloneNotSupportedException {

    User user = null;

    try {

    user = (User) super.clone();

    } catch (CloneNotSupportedException e){

    e.printStackTrace();

    }

    return user;

    }

    }

    public class TestClone {

    public static void main(String[] args) throws CloneNotSupportedException {

    User user = new User("Tom",13);

    user.setTeacher(new Teacher("Jack",40));

    User userClone = user.clone();

    userClone.getTeacher().setName("Jerry");

    userClone.setName("Tom1");

    userClone.setAge(20);

    System.out.println(user.getName() + "|" + user.getAge() + "|" + user.getTeacher().getName());

    System.out.println(userClone.getName() + "|" + userClone.getAge() + "|" + userClone.getTeacher().getName());

    }

    }

    输出结果:

    Tom|13|Jerry

    Tom1|20|Jerry

    从输出结果可以看出,克隆对象修改name和age不会影响原对象,但对引用类型Teacher做修改,就会影响原对象

    深度克隆

    深度克隆就是把整个对象完全克隆一份,包括对象中的引用类型,如图所示

    9fdefeebd7ef63ebf63b2a35139aea61.png

    JDK没有提供尝试克隆的方法,只能我们自己来实现,把User类的clone()方法自己实现一下就可以实现简单的尝试克隆了

    @Override

    protected User clone() throws CloneNotSupportedException {

    User user = null;

    try {

    user = (User) super.clone();

    //克隆的时候new一个Teacher对象,就可以实现深度克隆

    Teacher te = new Teacher(this.teacher.getName(),this.teacher.getAge());

    user.setTeacher(te);

    } catch (CloneNotSupportedException e){

    e.printStackTrace();

    }

    return user;

    }

    这样就可以实现User对象的深度克隆了,是不是很简单?

    你以为这样就学会了深度克隆,那就真的太天真了,这里我只列举了一个最简单的对象

    实际在开发过程中遇到的对象远远比这个要复杂的多,可能包含多层对象的嵌套,如果都自己去实现的话,那就太麻烦了,而且容易出现BUG

    一种比较常用的实现方式是利用Java的序列化和反序列化

    对象序列化必须实现Serializable接口

    public class Teacher implements Serializable {

    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 class Teacher implements Serializable {

    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 class TestClone {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

    User user = new User("Tom",13);

    user.setTeacher(new Teacher("Jack",40));

    //序列化对象

    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

    objectOutputStream.writeObject(user);

    //反序列化对象

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

    ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

    User cloneUser = (User) objectInputStream.readObject();

    cloneUser.setName("Tom_clone");

    cloneUser.setAge(20);

    cloneUser.getTeacher().setName("Jack_clone");

    System.out.println(user.getName() + "|" + user.getAge() + "|" + user.getTeacher().getName());

    System.out.println(cloneUser.getName() + "|" + cloneUser.getAge() + "|" + cloneUser.getTeacher().getName());

    }

    }

    输出结果:

    Tom|13|Jack

    Tom_clone|20|Jack_clone

    可以看到已经完成了深度复杂,对引用类型的修改不会影响到原对象,这种方式的好处是不管对象嵌套多少层,对象进行序列化和反序列化之后,都会产生一个全新的对象

    注意:static 和 transient 类型的变量不会被序列化,所以这两种类型的深度克隆不能使用序列化的方式

    如果感觉对你有些帮忙,请收藏好,你的关注和点赞是对我最大的鼓励!

    如果想跟我一起学习,坚信技术改变世界,请关注【Java天堂】公众号,我会定期分享自己的学习成果,第一时间推送给您

    本文地址:https://blog.csdn.net/pzjtian/article/details/107501639

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • js对象的深度克隆

    2020-02-24 10:42:46
    在聊JavaScript(以下简称js)深度克隆之前,我们先来了解一下js中对象的组成。 在js中一切实例皆是对象,具体分为原始类型和合成类型:原始类型对象指的是Undefined、Null、Boolean、Number和String,按值传递。...
  • Java实现对象深度克隆

    2021-03-07 15:44:56
    实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下 import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io....
  • 结果:直接拷贝对象时,是地址拷贝,orig与dest指向同一个地址,导致修改dest会影响到orig 测试深度克隆拷贝相同类型对象: BeanOne orig = new BeanOne("123","张三","one"); //深度克隆 BeanOne dest = new ...
  • java深度克隆工具类

    2021-02-12 19:30:32
    image 结果:直接拷贝对象时,是地址拷贝,orig与dest指向同一个地址,导致修改dest会影响到orig 测试深度克隆拷贝相同类型对象: BeanOne orig = new BeanOne("123","张三","one");//深度克隆 BeanOne dest = new ...
  • java深度克隆

    2013-12-17 14:10:53
    java深度克隆,描述了深度克隆的几种方法
  • List深度克隆

    2020-03-24 13:34:03
    * @Description: List深度克隆 * @Param: source 源集合 * @Return: java.util.List<T> * @Author: CWR * @Date: 2019/12/26 16:17 */ public static <T> List<T> deepCopy(List<T> ...
  • 克隆的概念 克隆分为两种:深克隆和浅克隆 深克隆 所有元素或属性完全复制,与原对象完全脱离,也就是说所有对新...–ES6中我们可以通过Object.assign的方式来实现深度克隆。 1.javascript(ES5)中对象的克隆 function
  • js中的深度克隆的简单实现

    千次阅读 2018-08-31 09:40:24
    在js中,拷贝可以分为深拷贝(深度克隆)和浅拷贝两种。 浅拷贝:对拷贝后的数据进行修改会影响原数据的一种拷贝方式。 深拷贝(深度克隆):对拷贝后的数据进行修改不会影响原数据的一种拷贝方式。 按照一般的...
  • 主要给大家介绍了关于JavaScript浅层克隆与深度克隆的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 题外知识 1. 浅度克隆 基本(原始)数据类型为值传递 引用数据类型:仍为引用传递 2. 深度度克隆 ...// 对象深度克隆 function clone(obj) { var buf; if (obj instanceof Array) { buf = []; let
  • go-clone:深度克隆任何Go数据 包clone提供了对任何Go数据进行深度克隆的功能。 它还提供了一个包装器,以保护指针免受任何意外的突变。 Clone / Slowly可以克隆任何结构的未导出字段。 明智地使用此功能。 安装 ...
  • 主要介绍了JavaScript对象之深度克隆介绍,本文详细的讲解了什么是对象深度克隆,并给出了示例代码,需要的朋友可以参考下
  • javascript-es6之深度克隆

    千次阅读 2019-04-10 21:08:27
    在讲深度克隆之前,我们需要了解一些知识点: 判断数据类型的方式: 1、typeof返回的数据类型:String Number Boolean Undefined Object Function 2、Object.prototype.toString.call(obj) 拷贝数据: 基本数据类型:...
  • 主要介绍了javascript浅层克隆、深度克隆对比及实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,456
精华内容 10,182
关键字:

深度克隆

友情链接: Ymurewritten.rar