精华内容
下载资源
问答
  • Java深度拷贝

    2021-03-09 15:36:36
    标签: Android 内存相关Why直接赋值无法断开引用浅拷贝在含有内部对象引用的时候无法断开引用断开引用防止内存溢出、防止同步修改1. 直接引用举例:public class A {public String name = "我是A";}A a = new A();A...

    标签: Android 内存相关

    Why

    直接赋值无法断开引用

    浅拷贝在含有内部对象引用的时候无法断开引用

    断开引用防止内存溢出、防止同步修改

    1. 直接引用

    举例:

    public class A {

    public String name = "我是A";

    }

    A a = new A();

    A b = a;

    b.name = "我是B";

    System.out.println("a : " + a.name + " b: " + b.name);

    结果: a : 我是B b: 我是B

    这就是直接引用,a和b引用的是同一个对象

    2. 浅拷贝

    举例:

    public class A implements Cloneable{

    public String name = "我是A";

    @Override

    protected Object clone(){

    Object o=null;

    try

    {

    o=(A)super.clone();//Object 中的clone()识别出你要复制的是哪一个对象。

    }

    catch(CloneNotSupportedException e)

    {

    System.out.println(e.toString());

    }

    return o;

    }

    }

    A a = new A();

    A b = (A) a.clone();

    b.name = "我是B";

    System.out.println("a : " + a.name + " b: " + b.name);

    结果: a : 我是A b: 我是B

    这个就是浅拷贝,看着a和b已经不是引用同一个对象了。到这里是不是觉得已经OK了,断开引用了就不需要在研究深拷贝了。如果仅是这种情况确实是可以了,但是A类中只有一个String的成员变量。

    我们看下这种情况

    public class A implements Cloneable{

    public String name = "我是A";

    public UserTest UserTest = new UserTest();

    @Override

    protected Object clone(){

    Object o=null;

    try

    {

    o=(A)super.clone();//Object 中的clone()识别出你要复制的是哪一个对象。

    }

    catch(CloneNotSupportedException e)

    {

    System.out.println(e.toString());

    }

    return o;

    }

    }

    A a = new A();

    a.UserTest.test = "我是第一个";

    A b = (A) a.clone();

    b.name = "我是B";

    b.UserTest.test = "我是第二个";

    System.out.println("a : " + a.name + " b: " + b.name);

    System.out.println("a test : " + a.UserTest.test + " b test: " + b.UserTest.test);

    结果:

    a : 我是A b: 我是B

    a test : 我是第二个 b test: 我是第二个

    第一条打印发现a和b已经不是一个对象了,但是第二个打印发现a对象中的变量UserTest和b对象中的变量是同一个对象。这就是浅拷贝的优缺点。

    优点: 实现简单,在只含有基础引用类型的时候可以实现断开引用

    缺点: 当含有对象引用类型的时候,clone并不能复制内部对象

    3. 深度拷贝

    public class A implements Cloneable{

    public String name = "我是A";

    public UserTest UserTest = new UserTest();

    @Override

    protected Object clone() {

    A o = null;

    try {

    o = (A) super.clone();// Object 中的clone()识别出你要复制的是哪一个对象。

    o.UserTest = (test.field.deepclone.UserTest) UserTest.clone();

    } catch (CloneNotSupportedException e) {

    System.out.println(e.toString());

    }

    return o;

    }

    }

    public class UserTest implements Cloneable{

    public String test;

    @Override

    protected Object clone() {

    Object o = null;

    try {

    o = (UserTest) super.clone();

    } catch (CloneNotSupportedException e) {

    System.out.println(e.toString());

    }

    return o;

    }

    }

    A a = new A();

    a.UserTest.test = "我是第一个";

    A b = (A) a.clone();

    b.name = "我是B";

    b.UserTest.test = "我是第二个";

    System.out.println("a : " + a.name + " b: " + b.name);

    System.out.println("a test : " + a.UserTest.test + " b test: " + b.UserTest.test);

    结果:

    a : 我是A b: 我是B

    a test : 我是第一个 b test: 我是第二个

    深度拷贝是在浅拷贝的基础上对内部的非基本引用类型再次进行拷贝,这样的话就是完全的两个对象之间不存在关联引用。

    How

    实现方式:

    使用clone和Cloneable接口逐级进行拷贝

    使用Serializable接口,将对象写入流中,在从流中重新读取生成新的对象

    使用Gson进行正反序列化,生成新的对象

    clone和Cloneable

    如同上面例子使用,如果遇到有子对象就要连子对象也做clone,碰到列表等集合类要全都clone。

    使用Serializable接口

    例子:

    public class User implements Serializable{

    public String name;

    public String age;

    public UserTest test;

    public Object deepClone(){

    try {

    ByteArrayOutputStream bo = new ByteArrayOutputStream();

    ObjectOutputStream os = new ObjectOutputStream(bo);

    os.writeObject(this);

    ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());

    ObjectInputStream is = new ObjectInputStream(bi);

    return is.readObject();

    } catch (Exception e) {

    System.out.println("失败了:" + e.getMessage());

    }

    return null;

    }

    }

    public class UserTest implements Serializable{

    public String test;

    }

    通过Serializable接口将对象写入带流中,然后在读取回来生成新的对象。对于子类也是需要依赖Serializable接口的,否则会序列化失败。

    Gson序列化

    这个比较简单,通过以下代码可以看得出来使用方式。

    public User deep() {

    Gson gson = new Gson();

    return gson.fromJson(gson.toJson(this), User.class);

    }

    只需要通过Gson将对象转换成json字符,然后再将json转换回对象。对于内部对象没有要求。

    Compare

    对比

    clone

    Serializable

    Gson

    易用性

    在只含有基础引用对象的时候非常好用,在含有集合或者多层级的内部对象的时候非常复杂

    只需要在该类本身或者内部对象类上加上这个接口就可以了使用简单,对于集合不需要做特殊处理

    只需要两行代码不需要考虑是否含有内部对象

    扩展性

    扩展内部对象需要依次实现clone方法,不方便,对于集合扩展很麻烦

    扩展需要依次引用Serializable接口

    不需要变动代码

    性能

    clone 10000条耗时:4ms

    Serializable 10000条耗时:583ms

    gson 10000条耗时:868ms

    通过上述表格可以得出以上三种方法的优缺点和使用场景。

    clone:优点:适合于内部只有基础引用对象的类,系统出品性能非常好。可以做多次循环等频繁操作。

    缺点:含有集合变量的类不适合使用,容易变动的类也不适合使用。

    Serializable:比较中庸,比clone的优点差一点,比clone的缺点好一点,在没有太多层级引用关系并且有集合变量的时候比clone要适合使用

    Gson:优点:可以作为工具类,实现简单就两行代码不需要担心对象的结构,非常方便。

    缺点:消耗性能比较大,不适合频繁操作,只适合单次或者少量的使用。

    展开全文
  • react 深度拷贝

    2021-05-13 16:40:13
    let obj = {a: 1}; //分配一个新地址给newObj let newObj = Object.assign({},obj); //赋值 newObj.a = 2; console.log('最终list===最终list===最终list===最终list===最终list===',obj.a);...
            let obj = {a: 1};
    
    //分配一个新地址给newObj
            let newObj = Object.assign({},obj);
    //赋值
            newObj.a = 2;
            console.log('最终list===最终list===最终list===最终list===最终list===',obj.a);
            console.log('最终list===最终list===最终list===最终list===最终list===',newObj.a);
    
    展开全文
  • 深度拷贝与浅拷贝概念浅复制(浅克隆)被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。深复制(深克隆)...

    问题

    日常工作中,我们希望复制一个对象A的属性到对象B,且保证二者的变化不会互相影响。

    直接赋值,肯定是无法满足的。

    深度拷贝与浅拷贝

    概念

    浅复制(浅克隆)

    被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。

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

    深复制(深克隆)

    被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。

    那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。

    换言之,深复制把要复制的对象所引用的对象都复制了一遍。

    java clone 方法

    clone()

    clone方法将对象复制了一份并返回给调用者。一般而言,clone() 方法满足:

    ① 对任何的对象x,都有x.clone() !=x//克隆对象与原对象不是同一个对象

    ② 对任何的对象x,都有x.clone().getClass()==x.getClass()//克隆对象与原对象的类型一样

    ③ 如果对象x的equals()方法定义恰当,那么x.clone().equals(x)应该成立。

    Java中对象的克隆

    ① 为了获取对象的一份拷贝,我们可以利用Object类的clone()方法。

    ② 在派生类中覆盖基类的clone()方法,并声明为public。

    ③ 在派生类的clone()方法中,调用super.clone()。

    ④ 在派生类中实现Cloneable接口。

    使用例子

    class Student implements Cloneable

    {

    String name;

    int age;

    Student(String name,int age) {

    this.name=name;

    this.age=age;

    }

    public Object clone() {

    Object o=null;

    try {

    o=(Student)super.clone();//Object 中的clone()识别出你要复制的是哪一个对象。

    } catch(CloneNotSupportedException e) {

    System.out.println(e.toString());

    }

    return o;

    }

    }

    这种复制是一种浅复制。

    必须将对象中其他涉及到的对象,也显示 clone 一遍。

    这种方式比较麻烦,不是很建议使用。

    序列化来实现深拷贝

    概念

    把对象写到流里的过程是串行化(Serilization)过程,但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜(picking)”过程;

    而把对象从流中读出来的并行化(Deserialization)过程则叫做 “解冻”或者“回鲜(depicking)”过程。

    应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面,因此“腌成咸菜”的只是对象的一个拷贝,Java咸菜还可以回鲜。

    在Java语言里深复制一个对象,常常可以先使对象实现Serializable接口,然后把对象(实际上只是对象的一个拷贝)写到一个流里(腌成咸菜),再从流里读出来(把咸菜回鲜),便可以重建对象。

    代码

    如下为深复制源代码。

    public Object deepClone() {

    //将对象写到流里

    ByteArrayOutoutStream bo=new ByteArrayOutputStream();

    ObjectOutputStream oo=new ObjectOutputStream(bo);

    oo.writeObject(this);

    //从流里读出来

    ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());

    ObjectInputStream oi=new ObjectInputStream(bi);

    return(oi.readObject());

    }

    这种比较接近预期,但是要求所有的对象都要进行序列化。

    有时候就会很麻烦。

    使用三方工具

    apache 的 BeanUtils 方案

    使用org.apache.commons.beanutils.BeanUtils进行对象深入复制时候,主要通过向BeanUtils框架注入新的类型转换器。

    因为默认情况下,BeanUtils对复杂对象的复制是引用,例如:

    public static void beanUtilsTest() throws Exception {

    // 注册转化器

    BeanUtilsBean.getInstance().getConvertUtils().register(new ArbitrationConvert(), ArbitrationDO.class);

    Wrapper wrapper = new Wrapper();

    wrapper.setName("copy");

    wrapper.setNameDesc("copy complex object!");

    wrapper.setArbitration(newArbitrationDO());

    Wrapper dest = new Wrapper();

    // 对象复制

    BeanUtils.copyProperties(dest, wrapper);

    // 属性验证

    wrapper.getArbitration().setBizId("1");

    System.out.println(wrapper.getArbitration() == dest.getArbitration());

    System.out.println(wrapper.getArbitration().getBizId().equals(dest.getArbitration().getBizId()));

    }

    public class ArbitrationConvert implements Converter {

    @Override

    public T convert(Class type, Object value) {

    if (ArbitrationDO.class.equals(type)) {

    try {

    return type.cast(BeanUtils.cloneBean(value));

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    return null;

    }

    }

    可以发现,使用org.apache.commons.beanutils.BeanUtils复制引用时,主和源的引用为同一个,即改变了主的引用属性会影响到源的引用,所以这是一种浅拷贝。

    apache的PropertyUtils方案

    PropertyUtils的copyProperties()方法几乎与BeanUtils.copyProperties()相同,主要的区别在于后者提供类型转换功能,即发现两个JavaBean的同名属性为不同类型时,在支持的数据类型范围内进行转换,PropertyUtils不支持这个功能,所以说BeanUtils使用更普遍一点,犯错的风险更低一点。

    而且它仍然属于浅拷贝。

    Apache提供了 SerializationUtils.clone(T),T对象需要实现 Serializable 接口,他属于深克隆。

    spring 的 BeanUtils 方案

    Spring中的BeanUtils,其中实现的方式很简单,就是对两个对象中相同名字的属性进行简单get/set,仅检查属性的可访问性。

    public static void copyProperties(Object source, Object target) throws BeansException {

    copyProperties(source, target, (Class)null, (String[])null);

    }

    public static void copyProperties(Object source, Object target, Class> editable) throws BeansException {

    copyProperties(source, target, editable, (String[])null);

    }

    public static void copyProperties(Object source, Object target, String... ignoreProperties) throws BeansException {

    copyProperties(source, target, (Class)null, ignoreProperties);

    }

    private static void copyProperties(Object source, Object target, Class> editable, String... ignoreProperties) throws BeansException {

    Assert.notNull(source, "Source must not be null");

    Assert.notNull(target, "Target must not be null");

    Class actualEditable = target.getClass();

    if(editable != null) {

    if(!editable.isInstance(target)) {

    throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");

    }

    actualEditable = editable;

    }

    PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);

    List ignoreList = ignoreProperties != null?Arrays.asList(ignoreProperties):null;

    PropertyDescriptor[] var7 = targetPds;

    int var8 = targetPds.length;

    for(int var9 = 0; var9 < var8; ++var9) {

    PropertyDescriptor targetPd = var7[var9];

    Method writeMethod = targetPd.getWriteMethod();

    if(writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {

    PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());

    if(sourcePd != null) {

    Method readMethod = sourcePd.getReadMethod();

    if(readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {

    try {

    if(!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {

    readMethod.setAccessible(true);

    }

    Object ex = readMethod.invoke(source, new Object[0]);

    if(!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {

    writeMethod.setAccessible(true);

    }

    writeMethod.invoke(target, new Object[]{ex});

    } catch (Throwable var15) {

    throw new FatalBeanException("Could not copy property \'" + targetPd.getName() + "\' from source to target", var15);

    }

    }

    }

    }

    }

    }

    可以看到, 成员变量赋值是基于目标对象的成员列表, 并且会跳过ignore的以及在源对象中不存在的, 所以这个方法是安全的, 不会因为两个对象之间的结构差异导致错误, 但是必须保证同名的两个成员变量类型相同。

    BeanCopier

    性能比较好

    dozer

    Dozer(http://dozer.sourceforge.net/)能够实现深拷贝。

    Dozer是基于反射来实现对象拷贝,反射调用set/get 或者是直接对成员变量赋值。

    该方式通过invoke执行赋值,实现时一般会采用beanutil, Javassist等开源库。

    利用 json

    利用 json 序列化+反序列化,也可以实现深度复制。

    综上推荐使用:

    BeanUtils(简单,易用)

    BeanCopier(加入缓存后和手工set的性能接近)

    Dozer(深拷贝)

    fastjson(特定场景下使用)

    参考资料

    展开全文
  • Java List的深度拷贝方法

    千次阅读 2021-03-16 20:58:17
    为了了解真正的深拷贝是如何实现的,我终于在CSDN博客中找到了通过序列化实现List的深度拷贝的方法首先简单介绍一下序列化是什么:把对象转换为字节序列的过程称为对象的序列化,反之将字节序列恢复为对象的过程称为...

    为了了解真正的深拷贝是如何实现的,我终于在CSDN博客中找到了通过序列化实现List的深度拷贝的方法首先简单介绍一下序列化是什么:把对象转换为字节序列的过程称为对象的序列化,反之将字节序列恢复为对象的过程称为对象的反序列化。

    JDK类库中的序列化API:java.io.ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。

    java.io.ObjectInputStream代表对象输入流,它的readObject()方法从一个源输入流中读取字节序列,再把它们反序列化为一个对象,并将其返回。

    只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口,实现Externalizable接口的类完全由自身来控制序列化的行为,而仅实现Serializable接口的类可以 采用默认的序列化方式 。

    对象序列化包括如下步骤:

    1) 创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;

    2) 通过对象输出流的writeObject()方法写对象。

    对象反序列化的步骤如下:

    1) 创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;

    2) 通过对象输入流的readObject()方法读取对象。

    建立一个Person类,实现Serializable接口

    5a31266c6adc

    Person

    下面两个函数写在测试类中

    5a31266c6adc

    其中函数deepCopy就是利用序列化实现深拷贝,可以看到序列化和反序列化的过程与上文过程相同,不同的地方是,该程序里面用的并非文件输出(输入)流,而是字节数组(ByteArray)输出(输入流),文件输出(输入)流会将转化的字符序列存储在文件中,而字节数组输出(输入)流则是将其保存在一个字节数组的临时变量中,仅占用内存空间,用后会自动清除。

    然后再看这里面使用的是List的泛型类,目的就是能够使已经实现Serializable接口的Person类能够被函数所调用然后进行拷贝。

    而实现深度拷贝的原理是什么呢?首先已经知道浅拷贝的原因是两个开辟的空间同时指向了同一个顺序表而导致对其中一个进行操作时,另一个也会受到影响。而当把对象序列化并存储后,再将其反序列化(反序列化返回的是一个对象),这时候反序列化得到的对象的存储位置已经与原对象不同了,也就是在反序列化后产生了两个一毛一样的对象,但它们并不是同一个。这时候将用于拷贝的空间用新的对象赋值即可实现深度拷贝。

    最后附上测试类和测试结果

    5a31266c6adc

    测试

    5a31266c6adc

    运行结果

    可以看出在对srcList进行修改后,拷贝得到的destList没有发生改变

    展开全文
  • 文章目录一、前言二、序列化标记三、浅拷贝复制四、深度拷贝复制:.net 5版本以前五、深度拷贝复制:.net 5 以后 .net core六、深度拷贝复制:独立封装七、总结 一、前言 开发过程中经常会遇到某个引用类型对象类...
  • 前言: 今天在复习numpy的时候,在看那个array...相关内容同步更新与个人博客系统:从numpy中学习深度拷贝和浅拷贝 首先看一下百度对深拷贝和浅拷贝的释义: 深拷贝 深拷贝是指源对象与拷贝对象互相独立,其中任何一个对象
  • java序列化与深度拷贝

    2021-11-20 13:58:57
    // zhangsan } 【2.1.2】深度拷贝 /** * @description 测试用例-基于 Serializable接口自动实现序列化的深度拷贝 * @author xiao tang * @date 2021/11/20 */ public static void main(String[] args) throws ...
  • Java在复制一个对象时有浅拷贝与深拷贝之分,具体区别就不在此赘述,本文主要分析Java深拷贝的几种方法以及他们的效率高低。1. 使用Java序列化方法想要深拷贝一个对象,常用的方法是序列化为数据流,此方法的前提是...
  • Dozer是一个Java Bean的转换组件,它可以将一个对象递归拷贝到另外一个对象,支持简单属性映射,复杂类型映射,双向映射,隐式显式映射以及递归映射。 具体应用 依赖 <!-- dozermapper --> <dependency&...
  • 前言Java的深度拷贝大致分为克隆(实现Java的Clone接口)和序列化(实现Java的Serializable接口)两种,但是基于不同的序列化方式,有可以延伸出几种方式。下面分析一下每种的注意事项和性能对比【当前电脑为4核16G,...
  • 深度拷贝指的是将一个引用类型(包含该类型里的引用类型)拷贝一份(在内存中完完全全是两个对象,没有任何引用关系) #利用json序列化实现对象深拷贝 1、利用System.Text.Json System.Text.Json 命名空间提供用于...
  • 什么是深度拷贝 需求复制一个People类,不考虑new一个 如果这么做的话发生的是引用传递,也就是将指向p1所指向内存空间的地址传递给了p2,也就是p1与p2指向同一个内存,所以改变p2的值p1也会改变,这就是浅度拷贝 ...
  • Java 深度拷贝

    2021-03-06 03:23:19
    public Object deepCopy(Object source){Object destination = new Object() ;ByteArrayOutputStream bo = null;ObjectOutputStream oo = null ;ByteArrayInputStream bi = null ;ObjectInputStream oi = null ;...
  • "sec4","sec3":"sec3"}] 用后边的这种流的方式MT4使用教程才是深度拷贝(使用序列化方法) 目标数组元素:[{"sec2":"des2","sec1":"sec1"},{"sec4":"sec4","sec3":"sec3"}] 目标数组元素:[{"sec2":"des2","sec1":"sec...
  • vue对象深度拷贝

    2021-04-25 11:23:56
    // 对象深度拷贝 export function deepClone(source) { // 判断复制的目标是数组还是对象 const targetObj = source.constructor === Array ? [] : {} for (const keys in source) { if (source.hasOwnProperty...
  • } //当然前题是List中的对象要实现ICloneable接口 } 2、另一种用序列化的方式对引用对象完成深拷贝,此种方法最可靠 public static T Clone(T RealObject) { using (Stream objectStream = new MemoryStream()) { /...
  • //深拷贝,基于楼下Copy函数 QUEUE& operator=(const QUEUE&);//同上 ~QUEUE();//析构 public: void Inque(int);//入队 void Deque();//出队 bool Isempty();//判空 int GetSize();//获得长度 void MakeEmpty...
  • 深度 拷贝

    2021-12-11 18:21:25
  • 安装lodash 打开项目的终端进行npm安装 npm i lodash 在文件中引入lodash xx.vue 的script头部部分 import _ from "lodash" 在文件中使用lodash 定义变量=需要克隆的对象 ...const form = _.cloneDeep(this.addForm)...
  • vue 深度拷贝

    2021-06-08 08:21:03
    let filterForm = JSON.parse(JSON.stringify(this.form))
  • java list深度拷贝

    2021-03-22 11:49:46
    java如何深度copy一个object?例如 Image对象如何复制创建Employer类,实现Cloneable接口: class Employer implements Cloneable{ private String username; public String getUsername() { return username; } ...
  • 深度拷贝

    2021-03-15 15:57:58
    拷贝思路1: 将对象进行序列化,把得到的字节序列写到一个目标输出流中。再从一个源输入流中读取 字节序列,再把它们反序列化为一个对象。 拷贝思路2: 将对象转成字符串,再通过json类将String转成对象。 public ...
  • 深度拷贝封装函数

    2021-06-25 09:08:22
    深度拷贝封装函数 function DeepCopy(obj) { if (typeof obj !== 'object' || obj === null) return obj let request obj instanceof Array ? request = [] : request = {} for (let i in obj) { request[i] = ...
  • 算法热门:深度拷贝带随机指针的链表(LeetCode 138)

    多人点赞 热门讨论 2021-08-08 13:13:59
    深度拷贝带随机指针的链表?没那么简单! 超详细讲解
  • 拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。 #!/usr/bin/python # -*-coding:utf-8 -*- import copy a = [1, 2, 3, 4,...
  • import copy params = self.query() lis = [{"code": "3","value": "WW", "seq_sign":"w","status":0},{"code": "4","value": "QQ", "seq_sign":"w","status":0}] lis2 = [] default = {"code": "", "value": "", ...
  • js 基本数据类型 和 深度拷贝的关系 js的基本数据类型包括:string number boolean undefined null symbol js的引用数据类型包括:Array Object function json 基本数据类型定义的变量名和值都存在 栈内 ...
  • 链表--深度拷贝一个带有随机指针的链表链表--深度拷贝一个带有随机指针的链表本文介绍两种解法。解法1:利用一个mapListNode *copyRandomList(ListNode *head){if(head == NULL || head->next == NULL)return ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,741
精华内容 31,496
关键字:

深度拷贝