Java对象浅克隆、深克隆及序列化

2019独角兽企业重金招聘Python工程师标准>>>

这里我们就可以引入两个专业的术语&＃xff1a;浅克隆&＃xff08;shallow clone&＃xff09;和深克隆&＃xff08;deep clone&＃xff09;。

所谓的浅克隆&＃xff0c;顾名思义就是很表面的很表层的克隆&＃xff0c;如果我们要克隆Administrator对象&＃xff0c;只克隆他自身以及他包含的所有对象的引用地址。而深克隆&＃xff0c;就是非浅克隆。克隆除自身以外所有的对象&＃xff0c;包括自身所包含的所有对象实例。至于深克隆的层次&＃xff0c;由具体的需求决定&＃xff0c;也有“N层克隆”一说。但是&＃xff0c;所有的基本&＃xff08;primitive&＃xff09;类型数据&＃xff0c;无论是浅克隆还是深克隆&＃xff0c;都会进行原值克隆。毕竟他们都不是对象&＃xff0c;不是存储在堆中。&＃xff08;Java中所有的对象都是保存在堆中&＃xff0c;而堆是供全局共享的。也就是说&＃xff0c;如果同一个Java程序的不同方法&＃xff0c;只要能拿到某个对象的引用&＃xff0c;引用者就可以随意的修改对象的内部数据。&＃xff09;

要让一个对象进行克隆&＃xff0c;其实就是两个步骤&＃xff1a;1. 让该类实现java.lang.Cloneable接口&＃xff1b;2. 重写&＃xff08;override&＃xff09;Object类的clone()方法。&＃xff08;并且在方法内部调用持有对象的clone()方法&＃xff1b;如果有N多个持有的对象&＃xff0c;那就要写N多的方法&＃xff0c;突然改变了类的结构&＃xff0c;还要重新修改clone()方法。&＃xff09;

public class CloneBean implements Serializable,Cloneable{
private String st1 ;
private int i;

public String getSt1() {
  return st1;
}
public void setSt1(String st1) {
  this.st1 &＃61; st1;
}
public int getI() {
  return i;
}
public void setI(int i) {
  this.i &＃61; i;
}

//可以实现自身的值克隆 &＃xff0c;如果在父类的克隆的时候&＃xff0c; 显示的调用自身的克隆&＃xff0c;并复制给
&＃64;Override
public Object clone() {
  CloneBean cb &＃61; null;
  try {
   cb &＃61; (CloneBean) super.clone();//要调用父类的 clone方法
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }
  return cb;
}
}

public class ShallowClone implements Cloneable {
// 基本类型每个对象一份
private int a;
private String b;

// 非基本类型数组对象&＃xff0c; 复制的对象保持一个引用&＃xff0c;相关的修改都会影响
private int[] c;
private CloneBean clonebean;

// 重写Object.clone()方法,并把protected改为public    《只是浅克隆&＃xff0c; 如果要实现真正的深克隆&＃xff0c;用到序列化及反序列化》
&＃64;Override
public Object clone() {
  ShallowClone sc &＃61; null;
  try {
   sc &＃61; (ShallowClone) super.clone();//要调用父类的 clone方法
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
  }

  //sc.clonebean&＃61;(CloneBean)clonebean.clone(); 显示的调用对象的克隆&＃xff0c;也可以保持对象的新值&＃xff0c;因为本身对象又是一个新的对象

  return sc;
}

public int getA() {
return a;
}

public void setA(int a) {
this.a &＃61; a;
}

public String getB() {
return b;
}

public void setB(String b) {
this.b &＃61; b;
}

public int[] getC() {
return c;
}

public void setC(int[] c) {
this.c &＃61; c;
}

public CloneBean getClonebean() {
return clonebean;
}

public void setClonebean(CloneBean clonebean) {
this.clonebean &＃61; clonebean;
}

}

public class ShallowCloneTest {
public static void main(String[] args) throws CloneNotSupportedException {
  ShallowClone c1 &＃61; new ShallowClone();
  // 对c1赋值
  c1.setA(100);
  c1.setB("clone1");
  c1.setC(new int[] { 1000 });
  CloneBean cb &＃61; new CloneBean();
  cb.setI(10);
  cb.setSt1("str1");
  c1.setClonebean(cb);

  System.out.println("克隆前: c1.a&＃61;" &＃43; c1.getA());
  System.out.println("克隆前: c1.b&＃61;" &＃43; c1.getB());
  System.out.println("克隆前: c1.c[0]&＃61;" &＃43; c1.getC()[0]);
  System.out.println("克隆前: c1.cb.str1&＃61;" &＃43; c1.getClonebean().getSt1());

  System.out.println("-----------");

  // 克隆出对象c2,并对c2的属性A,B,C进行修改
  ShallowClone c2 &＃61; (ShallowClone) c1.clone();
  // 对c2进行修改
  c2.setA(50);
  c2.setB("clone2");
  int[] a &＃61; c2.getC();
  a[0] &＃61; 500;
  c2.setC(a);

  CloneBean cb1 &＃61; c2.getClonebean();
  cb1.setSt1("tewtstewt");
  c2.setClonebean(cb1);

  System.out.println("克隆后: c1.a&＃61;" &＃43; c1.getA());
  System.out.println("克隆后: c1.b&＃61;" &＃43; c1.getB());
  System.out.println("克隆后: c1.c[0]&＃61;" &＃43; c1.getC()[0]);
  System.out.println("克隆后: c1.cb.str1&＃61;" &＃43; c1.getClonebean().getSt1());
  System.out.println("---------------");

  System.out.println("克隆后: c2.a&＃61;" &＃43; c2.getA());
  System.out.println("克隆后: c2.b&＃61;" &＃43; c2.getB());
  System.out.println("克隆后: c2.c[0]&＃61;" &＃43; c2.getC()[0]);
  System.out.println("克隆后: c2.cb.str1&＃61;" &＃43; c2.getClonebean().getSt1());
}
}

×××××××××××××××××××××用serializable来实现×××××××××××××××××××××××××××××××××××

//前提是对象以及对象内部所有引用到的对象都是可串行化的&＃xff0c;否则&＃xff0c;就需要仔细考察那些不可串行化的对象可否设成transient&＃xff0c;从而将之排除在复制过程之外。而类变量是全局的&＃xff0c;也不作序列化操作。
public class DeepClone implements Serializable
{
private static final long serialVersionUID &＃61; -4371342386287259388L;

    private transient String transi;//修饰为不可瞬时的不可序列化对象
public static int k;

private int a;
    private String b;

    private int[] c;
    private CloneBean cb;//必须也是可串行化的

    public int getA()
    {
        return a;
    }
    public void setA(int a)
    {
        this.a &＃61; a;
    }
    public String getB()
    {
        return b;
    }
    public void setB(String b)
    {
        this.b &＃61; b;
    }
    public int[] getC()
    {
        return c;
    }
    public void setC(int[] c)
    {
        this.c &＃61; c;
    }
public CloneBean getCb() {
  return cb;
}
public void setCb(CloneBean cb) {
  this.cb &＃61; cb;
}
public String getTransi() {
  return transi;
}
public void setTransi(String transi) {
  this.transi &＃61; transi;
}
public static int getK() {
  return k;
}
public static void setK(int k) {
  DeepClone.k &＃61; k;
}

// 用序列化与反序列化实现深克隆
public Object deepClone() {
  Object o &＃61; null;
  try {
   ByteArrayOutputStream baos &＃61; new ByteArrayOutputStream();
   ObjectOutputStream oos &＃61; new ObjectOutputStream(baos);
   oos.writeObject(this);
   oos.close();
   ByteArrayInputStream bais &＃61; new ByteArrayInputStream(baos
     .toByteArray());
   ObjectInputStream ois &＃61; new ObjectInputStream(bais);
   o &＃61; ois.readObject();
   ois.close();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  return o;
}

}

// 所有的对象都必须实现序列化接口
public class DeepCloneTest {
public static void main(String[] args) throws CloneNotSupportedException
    {
        DeepClone dc1 &＃61; new DeepClone();
        // 对dc1赋值
        dc1.setA(100);
        dc1.setB("clone1");
        dc1.setC(new int[] { 1000 });
        CloneBean cb &＃61; new CloneBean();
        cb.setSt1("deepClone...before...");
        dc1.setCb(cb);

        dc1.setTransi("transiant before");
        DeepClone.k&＃61;100;

        System.out.println("克隆前: dc1.a&＃61;" &＃43; dc1.getA());
        System.out.println("克隆前: dc1.b&＃61;" &＃43; dc1.getB());
        System.out.println("克隆前: dc1.c[0]&＃61;" &＃43; dc1.getC()[0]);
        System.out.println("克隆前: dc1.cd.str1&＃61;" &＃43; dc1.getCb().getSt1());

        System.out.println("克隆前: dc1.transiant&＃61;" &＃43; dc1.getTransi());
        System.out.println("克隆前: dc1.k&＃61;" &＃43; DeepClone.k);

        System.out.println("-----------");
        //序列化的所有对象都要实现序列化接口
        DeepClone dc2 &＃61; (DeepClone)dc1.deepClone();
        // 对c2进行修改
        dc2.setA(50);
        dc2.setB("clone2");
        int[] a &＃61; dc2.getC();
        a[0] &＃61; 500;
        dc2.setC(a);
        CloneBean cb2 &＃61; dc2.getCb();
        cb2.setSt1("deepClone...after...");
        dc2.setCb(cb2);

        System.out.println(dc2.getTransi());    //null值没有进行复用
        System.out.println(DeepClone.k);         //静态代码块不用串行化&＃xff0c;本身就是公用一块区域
        dc2.setTransi("transiant after");
        DeepClone.k&＃61;200;

        System.out.println("克隆前: dc1.a&＃61;" &＃43; dc1.getA());
        System.out.println("克隆前: dc1.b&＃61;" &＃43; dc1.getB());
        System.out.println("克隆前: dc1.c[0]&＃61;" &＃43; dc1.getC()[0]);
        System.out.println("克隆前: dc1.cd.str1&＃61;" &＃43; dc1.getCb().getSt1());
        System.out.println("克隆前: dc1.transiant&＃61;" &＃43; dc1.getTransi());
        System.out.println("克隆前: dc1.k&＃61;" &＃43; DeepClone.k);

        System.out.println("-----------");
        System.out.println("克隆后: dc2.a&＃61;" &＃43; dc2.getA());
        System.out.println("克隆后: dc2.b&＃61;" &＃43; dc2.getB());
        System.out.println("克隆后: dc2.c[0]&＃61;" &＃43; dc2.getC()[0]);
        System.out.println("克隆后: dc1.cd.str1&＃61;" &＃43; dc2.getCb().getSt1());
        System.out.println("克隆后: dc2.transiant&＃61;" &＃43; dc2.getTransi());
        System.out.println("克隆后: dc2.k&＃61;" &＃43; DeepClone.k);
    }
}