java对象拷贝

最新推荐文章于 2024-08-09 08:16:02 发布
最新推荐文章于 2024-08-09 08:16:02 发布
阅读量97 收藏
点赞数 2
分类专栏： java常用类 文章标签： java对象拷贝

java赋值是复制对象引用，如果我们想要得到一个对象的副本，使用赋值操作是无法达到目的的：

@Test
public void testassign(){
  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");

  Person p2=p1;
  System.out.println(p1==p2);//true
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

如果创建一个对象的新的副本，也就是说他们的初始状态完全一样，但以后可以改变各自的状态，而互不影响，就需要用到java中对象的复制，如原生的clone()方法。

如何进行对象克隆

Object对象有个clone()方法，实现了对象中各个属性的复制，但它的可见范围是protected的，所以实体类使用克隆的前提是：

① 实现Cloneable接口，这是一个标记接口，自身没有方法。
② 覆盖clone()方法，可见性提升为public。

@Data
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

@Test
public void testShallowCopy() throws Exception{
  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");

  Person p2=(Person) p1.clone();
  System.out.println(p1==p2);//false
  p2.setName("Jacky");
  System.out.println("p1="+p1);//p1=Person [name=Peter, age=31]
  System.out.println("p2="+p2);//p2=Person [name=Jacky, age=31]
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

该测试用例只有两个基本类型的成员，测试达到目的了。

事情貌似没有这么简单，为Person增加一个Address类的成员：

@Data
public class Address {
    private String type;
    private String value;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

再来测试，问题来了。

@Test
public void testShallowCopy() throws Exception{
  Address address=new Address();
  address.setType("Home");
  address.setValue("北京");

  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");
  p1.setAddress(address);

  Person p2=(Person) p1.clone();
  System.out.println(p1==p2);//false

  p2.getAddress().setType("Office");
  System.out.println("p1="+p1);
  System.out.println("p2="+p2);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

查看输出：

false
p1=Person(name=Peter, age=31, address=Address(type=Office, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))
 
 
  • 1
  • 2
  • 3

遇到了点麻烦，只修改了p2的地址类型，两个地址类型都变成了Office。

浅拷贝和深拷贝

前面实例中是浅拷贝和深拷贝的典型用例。

浅拷贝：被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象。

深拷贝：在浅拷贝的基础上，所有引用其他对象的变量也进行了clone，并指向被复制过的新对象。

也就是说，一个默认的clone()方法实现机制，仍然是赋值。

如果一个被复制的属性都是基本类型，那么只需要实现当前类的cloneable机制就可以了，此为浅拷贝。

如果被复制对象的属性包含其他实体类对象引用，那么这些实体类对象都需要实现cloneable接口并覆盖clone()方法。

@Data
public class Address implements Cloneable {
    private String type;
    private String value;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这样还不够，Person的clone()需要显式地clone其引用成员。

@Data
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj=super.clone();
        Address a=((Person)obj).getAddress();
        ((Person)obj).setAddress((Address) a.clone());
        return obj;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

重新跑前面的测试用例：

false
p1=Person(name=Peter, age=31, address=Address(type=Home, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))
 
 
  • 1
  • 2
  • 3

clone方式深拷贝小结

① 如果有一个非原生成员，如自定义对象的成员，那么就需要：

  • 该成员实现Cloneable接口并覆盖clone()方法，不要忘记提升为public可见。
  • 同时，修改被复制类的clone()方法，增加成员的克隆逻辑。

② 如果被复制对象不是直接继承Object，中间还有其它继承层次，每一层super类都需要实现Cloneable接口并覆盖clone()方法。

与对象成员不同，继承关系中的clone不需要被复制类的clone()做多余的工作。

一句话来说，如果实现完整的深拷贝，需要被复制对象的继承链、引用链上的每一个对象都实现克隆机制。

前面的实例还可以接受，如果有N个对象成员，有M层继承关系，就会很麻烦。

利用序列化实现深拷贝

clone机制不是强类型的限制，比如实现了Cloneable并没有强制继承链上的对象也实现；也没有强制要求覆盖clone()方法。因此编码过程中比较容易忽略其中一个环节，对于复杂的项目排查就是困难了。

要寻找可靠的，简单的方法，序列化就是一种途径。

  • 被复制对象的继承链、引用链上的每一个对象都实现java.io.Serializable接口。这个比较简单，不需要实现任何方法，serialVersionID的要求不强制，对深拷贝来说没毛病。

  • 实现自己的deepClone方法，将this写入流，再读出来。俗称：冷冻-解冻。

@Data
public class Person implements Serializable {
    private String name;
    private Integer age;
    private Address address;
    public Person deepClone() {
        Person p2=null;
        Person p1=this;
        PipedOutputStream out=new PipedOutputStream();
        PipedInputStream in=new PipedInputStream();
        try {
            in.connect(out);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try(ObjectOutputStream bo=new ObjectOutputStream(out);
                ObjectInputStream bi=new ObjectInputStream(in);) {
            bo.writeObject(p1);
            p2=(Person) bi.readObject();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return p2;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

原型工厂类

为了便于测试，也节省篇幅，封装一个工厂类。

公平起见，避免某些工具库使用缓存机制，使用原型方式工厂。

public class PersonFactory{
    public static Person newPrototypeInstance(){
        Address address = new Address();
        address.setType("Home");
        address.setValue("北京");

        Person p1 = new Person();
        p1.setAddress(address);
        p1.setAge(31);
        p1.setName("Peter");
        return p1;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

利用Dozer拷贝对象

Dozer是一个Bean处理类库。

maven依赖

<dependency>
  <groupId>net.sf.dozer</groupId>
  <artifactId>dozer</artifactId>
  <version>5.5.1</version>
</dependency>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

测试用例：

@Data
public class Person {
    private String name;
    private Integer age;
    private Address address;

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        Person p2 = mapper.map(p1, Person.class);
        p2.getAddress().setType("Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}

@Data
public class Address {
    private String type;
    private String value;
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

输出：

p1=Person(name=Peter, age=31, address=Address(type=Home, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))
 
 
  • 1
  • 2

注意：在万次测试中dozer有一个很严重的问题，如果DozerBeanMapper对象在for循环中创建，效率（dozer:7358）降低近10倍。由于DozerBeanMapper是线程安全的，所以不应该每次都创建新的实例。可以自带的单例工厂DozerBeanMapperSingletonWrapper来创建mapper，或集成到spring中。

还有更暴力的，创建一个People类：

@Data
public class People {
    private String name;
    private String age;//这里已经不是Integer了
    private Address address;

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        People p2 = mapper.map(p1, People.class);
        p2.getAddress().setType("Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

只要属性名相同，干~

继续蹂躏：

@Data
public class People {
    private String name;
    private String age;
    private Map<String,String> address;//��

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        People p2 = mapper.map(p1, People.class);
        p2.getAddress().put("type", "Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

利用Commons-BeanUtils复制对象

maven依赖

<dependency>
  <groupId>commons-beanutils</groupId>
  <artifactId>commons-beanutils</artifactId>
  <version>1.9.3</version>
</dependency>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

测试用例：

@Data
public class Person {
    private String name;
    private String age;
    private Address address;

    @Test
    public void testCommonsBeanUtils(){
    Person p1=PersonFactory.newPrototypeInstance();
        try {
            Person p2=(Person) BeanUtils.cloneBean(p1);
            System.out.println("p1=" + p1);
            p2.getAddress().setType("Office");
            System.out.println("p2=" + p2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

利用cglib复制对象

maven依赖：

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.2.4</version>
</dependency>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

测试用例：

@Test
public void testCglib(){
  Person p1=PersonFactory.newPrototypeInstance();
  BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, false);
  Person p2=new Person();
  beanCopier.copy(p1, p2,null);
  p2.getAddress().setType("Office");
  System.out.println("p1=" + p1);
  System.out.println("p2=" + p2);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

结果大跌眼镜，cglib这么牛x，居然是浅拷贝。不过cglib提供了扩展能力：

@Test
public void testCglib(){
  Person p1=PersonFactory.newPrototypeInstance();
  BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, true);
  Person p2=new Person();
  beanCopier.copy(p1, p2, new Converter(){
    @Override
    public Object convert(Object value, Class target, Object context) {
      if(target.isSynthetic()){
        BeanCopier.create(target, target, true).copy(value, value, this);
      }
      return value;
    }
  });
  p2.getAddress().setType("Office");
  System.out.println("p1=" + p1);
  System.out.println("p2=" + p2);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

Orika复制对象

orika的作用不仅仅在于处理bean拷贝，更擅长各种类型之间的转换。

maven依赖：

<dependency>
  <groupId>ma.glasnost.orika</groupId>
  <artifactId>orika-core</artifactId>
  <version>1.5.0</version>
</dependency>
</dependencies>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

测试用例：

@Test
public void testOrika() {
  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

  mapperFactory.classMap(Person.class, Person.class)
  .byDefault()
  .register();
  ConverterFactory converterFactory = mapperFactory.getConverterFactory();
  MapperFacade mapper = mapperFactory.getMapperFacade();

  Person p1=PersonFactory.newPrototypeInstance();
  Person p2 = mapper.map(p1, Person.class);
  System.out.println("p1=" + p1);
  p2.getAddress().setType("Office");
  System.out.println("p2=" + p2);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

Spring BeanUtils复制对象

给Spring个面子，貌似它不支持深拷贝。

Person p1=PersonFactory.newPrototypeInstance();
Person p2 = new Person();
Person p2 = (Person) BeanUtils.cloneBean(p1);
//BeanUtils.copyProperties(p2, p1);//这个更没戏
 
 
  • 1
  • 2
  • 3
  • 4

深拷贝性能对比

@Test
public void testBatchDozer(){
  Long start=System.currentTimeMillis();
  Mapper mapper = new DozerBeanMapper();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2 = mapper.map(p1, Person.class);
  }
  System.out.println("dozer:"+(System.currentTimeMillis()-start));
  //dozer:721
}
@Test
public void testBatchBeanUtils(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    try {
      Person p2=(Person) BeanUtils.cloneBean(p1);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  System.out.println("commons-beanutils:"+(System.currentTimeMillis()-start));
  //commons-beanutils：229
}
@Test
public void testBatchCglib(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, true);
    Person p2=new Person();
    beanCopier.copy(p1, p2, new Converter(){
      @Override
      public Object convert(Object value, Class target, Object context) {
        if(target.isSynthetic()){
          BeanCopier.create(target, target, true).copy(value, value, this);
        }
        return value;
      }
    });
  }
  System.out.println("cglib:"+(System.currentTimeMillis()-start));
  //cglib:133
}
@Test
public void testBatchSerial(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2=p1.deepClone();
  }
  System.out.println("serializable:"+(System.currentTimeMillis()-start));
  //serializable:687
}
@Test
public void testBatchOrika() {
  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

  mapperFactory.classMap(Person.class, Person.class)
  .field("name", "name")
  .byDefault()
  .register();
  ConverterFactory converterFactory = mapperFactory.getConverterFactory();
  MapperFacade mapper = mapperFactory.getMapperFacade();

  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2 = mapper.map(p1, Person.class);
  }
  System.out.println("orika:"+(System.currentTimeMillis()-start));
  //orika:83
}

@Test
public void testBatchClone(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    try {
      Person p2=(Person) p1.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }
  System.out.println("clone:"+(System.currentTimeMillis()-start));
  //clone:8
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89

（10k）性能比较：

//dozer:721
//commons-beanutils：229
//cglib:133
//serializable:687
//orika:83
//clone:8
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

深拷贝总结

原生的clone效率无疑是最高的，用脚趾头都能想到。

偶尔用一次，用哪个都问题都不大。

一般性能要求稍高的应用场景，cglib和orika完全可以接受。

另外一个考虑的因素，如果项目已经引入了某个依赖，就用那个依赖来做吧，没必要再引入一个第三方依赖。

hyr2468
关注
专栏目录
如何正确实现JAVA对象拷贝：深入剖析拷贝机制，避免“拷”入歧途
夏日清风
04-06 515
本篇博客将讲解深拷贝和浅拷贝的区别，介绍JAVA对象拷贝的实现方式，以及详细阐述对象拷贝的激活机制，并提供代码示例。希望你能从本文中获得有价值的知识和经验。
【Java基础】2.对象拷贝
qq_42011355的博客
12-07 3926
Java基础知识
Vue前端面试题总结（六）深拷贝和浅拷贝详解
Rick_and_mode的博客
09-15 743
深拷贝和浅拷贝 什么是深拷贝 深拷贝相对于对象方法的时候 是全部拷贝 意思就是直接复制在一份完整的对象或者方法 就好比我创建了一个a 利用深拷贝 复制出了 b 但是b不会对原来的a数据有任何影响 只是把原有a的值 完完整整复制到b里面 两个互不干涉 没有影响 什么是浅拷贝 而浅拷贝相比于深拷贝 对对象和方法则是引用 将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用 ...
Orika 开源项目安装与使用指南
最新发布
gitblog_00799的博客
08-09 959
Orika 开源项目安装与使用指南 orika项目地址:https://gitcode.com/gh_mirrors/or/orika 目录结构及介绍 在下载并解压了 Orika 的开源项目之后,其主要目录及其作用概述如下: core: 包含核心源代码实现。 examples: 提供示例程序来展示如何使用 Orika 进行 Bean 映射。 docs: 文档目录,其中包含了详细的用户指南和其他...
详解Java中的clone方法 -- 原型模式
热门推荐
昨夜星辰的博客
01-19 17万+
Java中对象的创建 clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。那么在java语言中，有几种方式可以创建对象呢？ 1 使用new操作符创建一个对象 2 使用clone方法复制一个对象 那么这两种方式有什么相同和不同呢？ new操作符的本意是分
Java的clone()方法
2301_76947341的博客
12-15 788
如果两个Person对象的name的地址值相同， 说明两个对象的name都指向同一个String对象， 也就是浅拷贝， 而如果两个对象的name的地址值不同， 那么就说明指向不同的String对象， 也就是在拷贝Person对象的时候， 同时拷贝了name引用的String对象， 也就是深拷贝。如果只是用Object中默认的clone方法，是浅拷贝的。深拷贝：根据Person源对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。
java对象拷贝常见面试题及应答汇总
08-24
Java对象拷贝常见面试题及应答汇总 在Java编程中，对象拷贝是一种常见的操作， 涉及到对象的复制和克隆。下面总结了一些常见的面试题和应答，供大家学习和参考。 为什么要使用克隆？ 在某些情况下，我们需要对一...
深入java对象复制的分析
09-05
Java对象复制是一个重要的概念，它涉及到对象的深拷贝和浅拷贝，以及如何通过不同的方式来实现对象的复制。本文将深入分析Java中的对象复制，主要包括两种常见方法：使用`clone()`方法和通过反射机制。 1. **Object...
java克隆对象(两种方法)
09-17
java的两种深度克隆方法,1cloneTest是用Cloneable接口的clone方法实现(对象必须要实现cloneable接口).2cloneSerialize.java是用对象流写对象到byte数组中,然后从byte数组中取得对象.(对象必须要实现serializble接口)
浅析java中clone（）方法
爱.NET
09-25 146
java中我们可能都遇到过这样的情况，在我们将一个对象做为参数传给一个函数的时候，我们希望在这个函数中所做的操做，并不会影响到这个对象本身。但是在java传递都是引用，所以往往我们在函数内部改变了对象的某一个值，在函数外面调用该对象的时候，相应的值也同样被改变了，例如下面的程序： class Test { static void myMethod(Point pt1) ...
Java中的clone方法
zzdnb的博客
04-03 1298
分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象（当然，由于指令的重排序，发布对象可能在构造函数返回之前，详细看。都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用源对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。
Java的clone()方法使用详解
drinkingcode
10-23 9613
前言： 我们知道，在java的object类中，有这么一个方法clone()，这个方法有什么用呢？怎样才能正确地使用这个方法呢？ 下面一一来进行阐述一下 clone()方法详解： 1>clone()方法的作用 顾名思义，clone()方法的作用就是克隆的意思，引入这个方法，这样就便于我们构建属于自己的一些本地对象副本。 这样我们就不用担心因为副本对象的引用而使原生的对象发生改变
java中的clone方法
weixin_44627672的博客
07-26 4488
java中的clone方法、深拷贝与浅拷贝、native方法
java对象clone()方法
萧曳丶
11-11 246
出处
Java中的clone()方法
yygr的博客
01-12 1万+
clone()方法的约定 Cloneable接口的目的是作为对象的一个混合接口，表明这样的对象允许克隆（clone），但是这个接口却没有定义clone()，这是它的缺陷：无法约束子类实现clone()方法。Object定义了一个受保护的clone()方法。Cloneable虽然没有定义clone()方法，但是却影响了Object.clone()方法的行为：如果一个类实现了Cloneable，调用Object的clone()就会返回该对象的逐域拷贝，否则抛出CloneNotSupportedException
java中的 clone方法
tall_fish的博客
02-12 773
java中，clone方法用于复制对象，是一种创建对象的方式。另一种创建对象的方法就是使用new操作符。new操作符的大致流程是先根据new后的类型确定需要分配多大的内存空间，然后调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象就创建完毕了，然后返回它的地址。clone方法的大致流程与new操作符类似，第一步是分配内存，大小与调用clone方法对象的内存相同，然后将使
java clone 方法
kfyong的专栏
02-15 600
他是原型模式的典型例子； 该方法是复制字节码，底层是用了C，直接读字节流完成，并没走构造方法、执行创建对象和赋值操作。 但是简单的clone方法，是只能针对java的八大数据类型和String来做的， 其他类型没办法直接clone成功，比如list，如果clone时，虽然数据可以在新的实例中显示 但是他并没生成新的对象，依然指向被克隆的对象地址； 这种就是我们说的浅克隆；   深克隆...
Java对象复制：浅拷贝与深拷贝解析
"Java对象的复制主要有三种方式：通过属性逐个赋值、重写`clone()`方法以及使用Apache Commons的工具类BeanUtils和PropertyUtils。以下是对这三种方式的详细解释。 1、通过属性逐个赋值 这种方式是最基础的复制方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值