yeskery

Java 的对象克隆

Category：软件开发 Tag：Java 2017-12-22 Views：208

前言

假如说你想复制一个简单变量。很简单：

  1. int apples = 5;
  2. int pears = apples;

不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。

但是如果你复制的是一个对象，情况就有些复杂了。

假设说我是一个beginner，我会这样写：

  1. class Student {
  2.     private int number;
  4.     public int getNumber() {
  5.         return number;
  6.     }
  8.     public void setNumber(int number) {
  9.         this.number = number;
  10.     }
  12. }
  13. public class Test {
  15.     public static void main(String args[]) {
  16.         Student stu1 = new Student();
  17.         stu1.setNumber(12345);
  18.         Student stu2 = stu1;
  20.         System.out.println("学生1:" + stu1.getNumber());
  21.         System.out.println("学生2:" + stu2.getNumber());
  22.     }
  23. }

结果：

  1. 学生1:12345
  2. 学生2:12345

这里我们自定义了一个学生类，该类只有一个number字段。

我们新建了一个学生实例，然后将该值赋值给stu2实例。(Student stu2 = stu1;)

再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此，

难道真的是这样吗？

我们试着改变stu2实例的number字段，再打印结果看看：

  1. stu2.setNumber(54321);
  3. System.out.println("学生1:" + stu1.getNumber());
  4. System.out.println("学生2:" + stu2.getNumber());

结果：

  1. 学生1:54321
  2. 学生2:54321

这就怪了，为什么改变学生2的学号，学生1的学号也发生了变化呢？

原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2，

这样，stu1和stu2指向内存堆中同一个对象。如图：
https://tencentsproutcdn.yeskery.com/2017/11/object_copy.png
那么，怎样才能达到复制一个对象呢？

是否记得万类之王Object。它有11个方法，有两个protected的方法，其中一个为clone方法。

在Java中所有的类都是缺省的继承自Java语言包中的Object类的，查看它的源码，你可以把你的JDK目录下的src.zip复制到其他地方然后解压，里面就是所有的源码。发现里面有一个访问限定符为protected的方法clone()：

  1. /*
  2. Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
  3. The general intent is that, for any object x, the expression:
  4. 1) x.clone() != x will be true
  5. 2) x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements.
  6. 3) x.clone().equals(x) will be true, this is not an absolute requirement.
  7. */
  8. protected native Object clone() throws CloneNotSupportedException;

仔细一看，它还是一个native方法，大家都知道native方法是非Java语言实现的代码，供Java程序调用的，因为Java程序是运行在JVM虚拟机上面的，要想访问到比较底层的与操作系统相关的就没办法了，只能由靠近操作系统的语言来实现。

  1. 第一次声明保证克隆对象将有单独的内存地址分配。
  2. 第二次声明表明，原始和克隆的对象应该具有相同的类类型，但它不是强制性的。
  3. 第三声明表明，原始和克隆的对象应该是平等的equals()方法使用，但它不是强制性的。

因为每个类直接或间接的父类都是Object，因此它们都含有clone()方法，但是因为该方法是protected，所以都不能在类外进行访问。

要想对一个对象进行复制，就需要对clone方法覆盖。

为什么要克隆？

大家先思考一个问题，为什么需要克隆对象？直接new一个对象不行吗？

答案是：克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。

提个醒，我们常见的Object a=new Object();Object b;b=a;这种形式的代码复制的是引用，即对象在内存中的地址，a和b对象仍然指向了同一个对象。

而通过clone方法赋值的对象跟原来的对象时同时独立存在的。

如何实现克隆

先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。

在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

一般步骤是（浅克隆）：

  1. 被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常)， 该接口为标记接口(不含任何方法)
  2. 覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象。（native为本地方法)

下面对上面那个方法进行改造：

  1. class Student implements Cloneable{
  2.     private int number;
  4.     public int getNumber() {
  5.         return number;
  6.     }
  8.     public void setNumber(int number) {
  9.         this.number = number;
  10.     }
  12.     @Override
  13.     public Object clone() {
  14.         Student stu = null;
  15.         try{
  16.             stu = (Student)super.clone();
  17.         }catch(CloneNotSupportedException e) {
  18.             e.printStackTrace();
  19.         }
  20.         return stu;
  21.     }
  22. }
  23. public class Test {
  24.     public static void main(String args[]) {
  25.         Student stu1 = new Student();
  26.         stu1.setNumber(12345);
  27.         Student stu2 = (Student)stu1.clone();
  29.         System.out.println("学生1:" + stu1.getNumber());
  30.         System.out.println("学生2:" + stu2.getNumber());
  32.         stu2.setNumber(54321);
  34.         System.out.println("学生1:" + stu1.getNumber());
  35.         System.out.println("学生2:" + stu2.getNumber());
  36.     }
  37. }

结果：

  1. 学生1:12345
  2. 学生2:12345
  3. 学生1:12345
  4. 学生2:54321

如果你还不相信这两个对象不是同一个对象，那么你可以看看这一句：

  1. System.out.println(stu1 == stu2); // false

上面的复制被称为浅克隆。

还有一种稍微复杂的深度复制：

我们在学生类里再加一个Address类。

  1. class Address  {
  2.     private String add;
  4.     public String getAdd() {
  5.         return add;
  6.     }
  8.     public void setAdd(String add) {
  9.         this.add = add;
  10.     }
  12. }
  14. class Student implements Cloneable{
  15.     private int number;
  17.     private Address addr;
  19.     public Address getAddr() {
  20.         return addr;
  21.     }
  23.     public void setAddr(Address addr) {
  24.         this.addr = addr;
  25.     }
  27.     public int getNumber() {
  28.         return number;
  29.     }
  31.     public void setNumber(int number) {
  32.         this.number = number;
  33.     }
  35.     @Override
  36.     public Object clone() {
  37.         Student stu = null;
  38.         try{
  39.             stu = (Student)super.clone();
  40.         }catch(CloneNotSupportedException e) {
  41.             e.printStackTrace();
  42.         }
  43.         return stu;
  44.     }
  45. }
  46. public class Test {
  48.     public static void main(String args[]) {
  50.         Address addr = new Address();
  51.         addr.setAdd("杭州市");
  52.         Student stu1 = new Student();
  53.         stu1.setNumber(123);
  54.         stu1.setAddr(addr);
  56.         Student stu2 = (Student)stu1.clone();
  58.         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
  59.         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
  60.     }
  61. }

结果：

  1. 学生1:123,地址:杭州市
  2. 学生2:123,地址:杭州市

乍一看没什么问题，真的是这样吗？

我们在main方法中试着改变addr实例的地址。

  1. addr.setAdd("西湖区");
  3. System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
  4. System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

结果：

  1. 学生1:123,地址:杭州市
  2. 学生2:123,地址:杭州市
  3. 学生1:123,地址:西湖区
  4. 学生2:123,地址:西湖区

这就奇怪了，怎么两个学生的地址都改变了？

原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：

  1. package abc;
  3. class Address implements Cloneable {
  4.     private String add;
  6.     public String getAdd() {
  7.         return add;
  8.     }
  10.     public void setAdd(String add) {
  11.         this.add = add;
  12.     }
  14.     @Override
  15.     public Object clone() {
  16.         Address addr = null;
  17.         try{
  18.             addr = (Address)super.clone();
  19.         }catch(CloneNotSupportedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         return addr;
  23.     }
  24. }
  26. class Student implements Cloneable{
  27.     private int number;
  29.     private Address addr;
  31.     public Address getAddr() {
  32.         return addr;
  33.     }
  35.     public void setAddr(Address addr) {
  36.         this.addr = addr;
  37.     }
  39.     public int getNumber() {
  40.         return number;
  41.     }
  43.     public void setNumber(int number) {
  44.         this.number = number;
  45.     }
  47.     @Override
  48.     public Object clone() {
  49.         Student stu = null;
  50.         try{
  51.             stu = (Student)super.clone();   //浅复制
  52.         }catch(CloneNotSupportedException e) {
  53.             e.printStackTrace();
  54.         }
  55.         stu.addr = (Address)addr.clone();   //深度复制
  56.         return stu;
  57.     }
  58. }
  59. public class Test {
  61.     public static void main(String args[]) {
  63.         Address addr = new Address();
  64.         addr.setAdd("杭州市");
  65.         Student stu1 = new Student();
  66.         stu1.setNumber(123);
  67.         stu1.setAddr(addr);
  69.         Student stu2 = (Student)stu1.clone();
  71.         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
  72.         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
  74.         addr.setAdd("西湖区");
  76.         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
  77.         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
  78.     }
  79. }

结果：

  1. 学生1:123,地址:杭州市
  2. 学生2:123,地址:杭州市
  3. 学生1:123,地址:西湖区
  4. 学生2:123,地址:杭州市

这样结果就符合我们的想法了。

最后我们可以看看API里其中一个实现了clone方法的类：

java.util.Date:

  1. /**
  2.  * Return a copy of this object.
  3.  */
  4. public Object clone() {
  5.     Date d = null;
  6.     try {
  7.         d = (Date)super.clone();
  8.         if (cdate != null) {
  9.             d.cdate = (BaseCalendar.Date) cdate.clone();
  10.         }
  11.     } catch (CloneNotSupportedException e) {} // Won't happen
  12.     return d;
  13. }

该类其实也属于深度复制。

浅克隆和深克隆

  • 浅克隆
    在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
https://tencentsproutcdn.yeskery.com/2017/11/sample_clone.png
在Java语言中，通过覆盖Object类的clone()方法可以实现浅克隆。

  • 深克隆
    在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。
https://tencentsproutcdn.yeskery.com/2017/11/deep_clone.png

在Java语言中，如果需要实现深克隆，可以通过覆盖Object类的clone()方法实现，也可以通过序列化(Serialization)等方式来实现。

（如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。）

序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

扩展

Java语言提供的Cloneable接口和Serializable接口的代码非常简单，它们都是空接口，这种空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。

解决多层克隆问题

如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。

  1. public class Outer implements Serializable{
  2.   private static final long serialVersionUID = 369285298572941L;  //最好是显式声明ID
  3.   public Inner inner;
  4. 　//Discription:[深度复制方法,需要对象及对象所有的对象属性都实现序列化]
  5.   public Outer myclone() {
  6.       Outer outer = null;
  7.       try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
  8.           ByteArrayOutputStream baos = new ByteArrayOutputStream();
  9.           ObjectOutputStream oos = new ObjectOutputStream(baos);
  10.           oos.writeObject(this);
  11. 　　　　　　// 将流序列化成对象
  12.           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  13.           ObjectInputStream ois = new ObjectInputStream(bais);
  14.           outer = (Outer) ois.readObject();
  15.       } catch (IOException e) {
  16.           e.printStackTrace();
  17.       } catch (ClassNotFoundException e) {
  18.           e.printStackTrace();
  19.       }
  20.       return outer;
  21.   }
  22. }

Inner也必须实现Serializable，否则无法序列化：

  1. public class Inner implements Serializable{
  2.   private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
  3.   public String name = "";
  5.   public Inner(String name) {
  6.       this.name = name;
  7.   }
  9.   @Override
  10.   public String toString() {
  11.       return "Inner的name值为：" + name;
  12.   }
  13. }

这样也能使两个对象在内存空间内完全独立存在，互不影响对方的值。

使用 BeanUtils 工具克隆对象

什么是BeanUtils工具

BeanUtils工具是一种方便我们对JavaBean进行操作的工具，是Apache组织下的产品。

BeanUtils工具一般可以方便javaBean的哪些操作？

  1. beanUtils 可以便于对javaBean的属性进行赋值。
  2. beanUtils 可以便于对javaBean的对象进行赋值。
  3. beanUtils可以将一个MAP集合的数据拷贝到一个javabean对象中。

BeanUtils的使用

  • 设置javaBean的参数

定义 Student bean

  1. package com.yeskery.test;
  3. import java.util.Date;
  5. public class Student {
  7.     private Integer id;
  9.     private String name;
  11.     private Integer age;
  13.     private Integer classId;
  15.     private Date birthday;
  17.     public Integer getId() {
  18.         return id;
  19.     }
  21.     public void setId(Integer id) {
  22.         this.id = id;
  23.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  33.     public Integer getAge() {
  34.         return age;
  35.     }
  37.     public void setAge(Integer age) {
  38.         this.age = age;
  39.     }
  41.     public Integer getClassId() {
  42.         return classId;
  43.     }
  45.     public void setClassId(Integer classId) {
  46.         this.classId = classId;
  47.     }
  49.     public Date getBirthday() {
  50.         return birthday;
  51.     }
  53.     public void setBirthday(Date birthday) {
  54.         this.birthday = birthday;
  55.     }
  56. }
  1. public static void main(String[] args) {
  2.     //先演示一下不用工具时的做法
  3.     //1.生成对象
  4.     Student s = new Student();
  6.     /*2.通过set方法赋值
  7.     s.setId(1);
  8.     s.setName("VN");
  9.     s.setAge(19);
  10.     s.setClassID(5);
  11.     s.setBirthday(new Date());
  12.     用以上这种方法来给对象的属性赋值实在是太麻烦了，下面我们用BeanUtils来进行赋值
  13.     */
  15.     //1.得到javaBean的一个字节码对象
  16.     Class clazz = Class.forName("com.yeskery.test.Student");
  18.     //2.生成该字节码的一个对象
  19.     Object obj = clazz.newInstance();
  21.     //4.注册一个日期格式转换器
  22.     ConvertUtils.register(new DateLocaleConverter(), java.util.Date.class);
  24.     //3.使用工具对该对象进行赋值
  25.     //注意： 对于基本数据类型，beanutils工具进行自动类型转换。把String自动转成Integer,Double,Float
  26.     BeanUtils.setProperty(obj, "id", "1");
  27.     BeanUtils.setProperty(obj, "name", "VN");
  28.     BeanUtils.setProperty(obj, "age", "19");
  29.     BeanUtils.setProperty(obj, "classID", "5");
  30.     //如果要使用特殊的日期类型，则String->Date 不能自动转换,这时候就要注册一个转换器
  31.     BeanUtils.setProperty(obj, "birthday", "1996-06-06");
  33.     System.out.println(obj);
  34. }

对比一下，我们发现，使用BeanUtils里赋值好像更麻烦。但这只是在这段代码中而已，运用BeanUtils上面代码的这个功能，

我们可以写出一个通用的方法，可以把请求中的参数拷贝到javaBean对象中。

  1. public static <T>T requestToBean(HttpServletRequest request , Class<T> clazz) {
  2.     //创建javaBean对象
  3.     Object obj=null;
  4.     try {
  5.         obj=clazz.newInstance();
  6.     } catch (Exception e) {
  7.         e.printStackTrace();
  8.         throw new RuntimeException(e);
  9.     }
  11.     //得到请求中的每个参数
  12.     Enumeration<String> enu = request.getParameterNames();
  13.     while(enu.hasMoreElements()) {
  14.         //获得参数名
  15.         String name = enu.nextElement();
  16.         //获得参数值
  17.         String value = request.getParameter(name);
  18.         //然后把参数拷贝到javaBean对象中
  19.         try {
  20.             BeanUtils.setProperty(obj, name, value);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.             throw new RuntimeException(e);
  24.         }
  25.     }
  26.     return (T)obj;
  27. }

上面这个方法是一个泛型方法，传不同的javaBean进去都可以从request中获取参数值。在一个工程较大的项目中，如果使用这个通用的方法，就能节省很多代码。

  • 把一个javaBean的属性拷贝到另一个javaBean对象中
  1. public static void main(String[] args) {
  2.     //1.生成对象
  3.     Student s1 = new Student();
  4.     Student s2 = new Student();
  6.     //2.通过set方法赋值
  7.     s1.setId(1);
  8.     s1.setName("VN");
  9.     //s1.setAge(19);//基本数据类型可以为null，null也能拷贝
  10.     s1.setClassID(5);
  11.     s1.setBirthday(new Date());//特殊类型不能为null
  13.     //需求：把s1的属性值拷贝到S2中，注意参数的顺序
  14.     BeanUtils.copyProperties(s2, s1);
  16.     System.out.println(s1);
  17.     System.out.println(s2);
  18. }

一句代码就完成拷贝了，不用像以前那样先用get()方法把s1的属性值拿出来，再用set()方法供给s2属性赋值。

  • 把一个map集合中的数据拷贝到javaBean中
  1. public static void main(String[] args) {
  2.     //1.生成对象
  3.     Map<String,Object> map = new HashMap<String,Object>();
  5.     //2.给一些参数
  6.     map.put("id", 2);
  7.     map.put("name", "EZ");
  8.     map.put("age", 22);
  9.     map.put("classID", 3);
  10.     map.put("birthday", new Date());
  12.     //需求：把map的属性值拷贝到S中
  13.     Student s = new Student();
  14.     BeanUtils.copyProperties(s, map);
  16.     System.out.println(s);
  17. }

上面这个也是一步到位，也是使用copyProperties()这个方法来完成，这样减少了我们很多的操作了，十分简便。

总结

实现对象克隆有两种方式：

  1. 实现Cloneable接口并重写Object类中的clone()方法；
  2. 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

本文转载自：https://www.cnblogs.com/Qian123/p/5710533.html
部分内容来自：https://www.cnblogs.com/vmax-tam/p/4159985.html

评论

Post comment Click Refresh verification code

Tip

The feature is not yet available

Close