JAVA中浅复制与深复制

 

1．浅复制与深复制概念 ⑴浅复制（浅克隆） 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 ⑵深复制（深克隆） 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 2．Java的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;
    }

    publicstaticvoid main(String[] args)
    ...{
          Student s1=new Student("zhangsan",18);
          Student s2=(Student)s1.clone();
          s2.name="lisi";
         s2.age=20;
         System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不影响学生1的值。
    }
}
 

说明： ①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。 ②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。

class Professor
...{
    String name;
    int age;
    Professor(String name,int age)
    ...{
        this.name=name;
        this.age=age;
    }
}
class Student implements Cloneable
...{
    String name;//常量对象。
    int age;
    Professor p;//学生1和学生2的引用值都是一样的。
    Student(String name,int age,Professor p)
    ...{
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object clone()
    ...{
        Student o=null;
        try
        ...{
            o=(Student)super.clone();
        }
        catch(CloneNotSupportedException e)
        ...{
            System.out.println(e.toString());
        }
        o.p=(Professor)p.clone();
        return o;
    }
    publicstaticvoid main(String[] args)
    ...{
          Professor p=new Professor("wangwu",50);
          Student s1=new Student("zhangsan",18,p);
          Student s2=(Student)s1.clone();
          s2.p.name="lisi";
         s2.p.age=30;
    System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授成为lisi,age为30。
    }
}

那应该如何实现深层次的克隆，即修改s2的教授不会影响s1的教授？代码改进如下。 改进使学生1的Professor不改变（深层次的克隆）

class Professor implements Cloneable
...{
    String name;
    int age;
    Professor(String name,int age)
    ...{
        this.name=name;
        this.age=age;
    }
    public Object clone()
    ...{
        Object o=null;
        try
        ...{
            o=super.clone();
        }
        catch(CloneNotSupportedException e)
        ...{
            System.out.println(e.toString());
        }
        return o;
    }
}
class Student implements Cloneable
...{
    String name;
    int age;
    Professor p;
    Student(String name,int age,Professor p)
    ...{
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object clone()
    ...{
        Student o=null;
        try
        ...{
            o=(Student)super.clone();
        }
        catch(CloneNotSupportedException e)
        ...{
            System.out.println(e.toString());
        }
        o.p=(Professor)p.clone();
        return o;
    }
    publicstaticvoid main(String[] args)
    ...{
          Professor p=new Professor("wangwu",50);
          Student s1=new Student("zhangsan",18,p);
          Student s2=(Student)s1.clone();
          s2.p.name="lisi";
         s2.p.age=30;
         System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授不改变。
    }

}

3．利用串行化来做深复制     把对象写到流里的过程是串行化（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());
}

       这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。

class Professor implements Serializable
...{
    String name;
    int age;
    Professor(String name,int age)
    ...{
        this.name=name;
        this.age=age;
    }
}
class Student implements Serializable
...{
    String name;//常量对象。
    int age;
    Professor p;//学生1和学生2的引用值都是一样的。
    Student(String name,int age,Professor p)
    ...{
        this.name=name;
        this.age=age;
        this.p=p;
    }
    public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException
    ...{
         //将对象写到流里
          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());
     }
    publicstaticvoid main(String[] args)
    ...{
           Professor p=new Professor("wangwu",50);
           Student s1=new Student("zhangsan",18,p);
           Student s2=(Student)s1.deepClone();
           s2.p.name="lisi";
          s2.p.age=30;
          System.out.println("name="+s1.p.name+","+"age="+s1.p.age); //学生1的教授不改变。
     }
}

4．参考资料

今天算是遇到一个问题了。相当苦恼。

需求如下：有2个相同id的对象，但它们的值不同。其中一个对象要用到另一个对象的属性值。

由于在hibernate的sessionFactory().getSession中不能存在2个相同id的对象。故此，想出复制对象。

找了很多地方，发现有2种方法可以达到复制对象的目的，只是最后这种方法还是没有解决我的问题。仅此记下来吧。

1，克隆clone

java支持克隆一个对象的值到另一个对象，简单的克隆和深度克隆，深度克隆可能包括继承，嵌套，没有用到，所以也就没怎么去研究它。

首先，克隆的对象需要实现 Cloneable接口，重写其中的clone()方法，为了使clone()方法在外部可用，需要将重写的方法访问修饰符改成public级别。

[java] @Override   

  public Object clone() throws CloneNotSupportedException {   

      return super.clone();  

   }

@Override public Object clone() throws CloneNotSupportedException {

  return super.clone();

}

[java] dv=(Deliverymanreport)deliverymanreport.clone();

//克隆对象

dv=(Deliverymanreport)deliverymanreport.clone();

//克隆对象

dv是deliverymanreport克隆的一个对象。 它拥用克隆后的属性和方法。

 

2，序列化和反序列化Serializable

序列化的对象要实现Serializable接口才能实现序列化。

序列化后，通过反序列化可以得到和当前对象一样的对象。它比克隆来得更准备。但也就不一定最好，如果这个对象在之前被修改，序列化后可能就会出问题了。

[java] ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

ObjectOutputStream out= new ObjectOutputStream(byteOut);

out.writeObject(deliverymanreport); //写对象，序列化 

ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray()); 

dv=(Deliverymanreport)in.readObject(); //读对象，反序列化

ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

ObjectOutputStream out= new ObjectOutputStream(byteOut);

out.writeObject(deliverymanreport); //写对象，序列化

ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());

dv=(Deliverymanreport)in.readObject(); //读对象，反序列化 序列化经常用于文件传递的读取。尤其是在缓存中用得比较多，通过序列化可以将对象缓存在硬盘中。这在登录系统缓存用户权限和角色等信息最常见。而用对克隆对象，也不失为一种很好的方法。

摘自  云淡风轻、仅此一抹

 

 注：字符串数组 list列表 等结构 都要手动复制 因为不重新开辟空间

 深复制： implements cloneable  Override clone函数  若类内有数组收到复制  若有类 则调用子类的clone赋值

个人测试super.clone对本类的字符串数组不具有重新分配空间功能

 

public class CloneTest {
 public static void main(String[] args) {
  String s = new String();
  s = "cat";
  Cat cat = new Cat(s);
  Cat catcopy;
  try {
   catcopy = (Cat) cat.clone();
   catcopy.name = "new";
   catcopy.mouse.name[0] = "abc0";
   System.out.println(catcopy.mouse.name[0]);
   System.out.println(cat.mouse.name[0]);
   catcopy.mouse.name[0] = "abc1";
   System.out.println(catcopy.name);
   System.out.println(cat.name);

   System.out.println(catcopy.mouse.name[0]);
   System.out.println(cat.mouse.name[0]);
  } catch (CloneNotSupportedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}

public class Cat implements Cloneable {
 String name;
 Mouse mouse;

 @Override
 public Object clone() throws CloneNotSupportedException {
  Cat clo = (Cat) super.clone();
  clo.mouse = (Mouse) mouse.clone();

  return clo;

 }

 public Cat(String input) {
  name = input;
  mouse = new Mouse(input);
 }
}

public class Mouse implements Cloneable {
 String name[] = new String[2];
 String sInput;

 Mouse(String input) {
  name[0] = input + "0";
  name[1] = input + "1";
  sInput = input;
 }

 @Override
 public Object clone() throws CloneNotSupportedException {
  return super.clone();
 }
}

输出abc0
abc0
new
cat
abc1
abc1