Java의 딥 카피 (딥 카피) 및 딥 카피 (딥 카피) 소개

깊은 복사(깊은 복사)와 얕은 복사(얕은 복사)는 두 가지 비교적 통용되는 개념이다. 특히 C++ 언어에서 이해하지 못하면 delete할 때 문제가 발생하지만, 우리는 여기서 다행히 자바를 사용한다.자바가 자동으로 대상의 회수를 관리하지만 깊은 복사(깊은 복사)와 얕은 복사(얕은 복사)에 대해 우리는 충분한 중시를 해야 한다. 왜냐하면 때때로 이 두 개념은 우리에게 적지 않은 곤혹을 가져오기 때문이다.
얕은 복사본은 객체를 복사할 때 객체 자체(객체의 기본 변수 포함)만 복사하고 객체에 포함된 참조가 가리키는 객체는 복사하지 않습니다.딥 카피는 객체 자체를 복제할 뿐만 아니라 복제 객체에 포함된 참조가 가리키는 모든 객체를 복제합니다.예를 들어 객체 A1에는 B1에 대한 참조가 포함되고 B1에는 C1에 대한 참조가 포함됩니다.얕은 복사본 A1은 A2를 얻었고 A2에는 B1에 대한 인용이 포함되었고 B1에는 C1에 대한 인용이 포함되었다.딥 카피는 얕은 카피에 대한 귀속이다. 딥 카피 A1은 A2를 얻고 A2는 B2(B1의copy)를 인용하며 B2는 C2(C1의copy)를 인용한다.
만약 clone () 방법을 바꾸지 않는다면, 이 방법을 호출하여 얻은 대상은 얕은 복사입니다. 다음은 깊은 복사에 중심을 두겠습니다.
다음 프로그램을 실행하여 간단한 복제본을 확인하십시오.

class Professor0 implements Cloneable { 
  String name; 
  int age; 
 
  Professor0(String name, int age) { 
    this.name = name; 
    this.age = age; 
  } 
 
  public Object clone() throws CloneNotSupportedException { 
    return super.clone(); 
  } 
} 
 
class Student0 implements Cloneable { 
  String name;//  。 
  int age; 
  Professor0 p;//  1 2 。 
 
  Student0(String name, int age, Professor0 p) { 
    this.name = name; 
    this.age = age; 
    this.p = p; 
  } 
 
  public Object clone() { 
    Student0 o = null; 
    try { 
      o = (Student0) super.clone(); 
    } catch (CloneNotSupportedException e) { 
      System.out.println(e.toString()); 
    } 
 
    return o; 
  } 
} 
 
public class ShallowCopy { 
  public static void main(String[] args) { 
    Professor0 p = new Professor0("wangwu", 50); 
    Student0 s1 = new Student0("zhangsan", 18, p); 
    Student0 s2 = (Student0) s1.clone(); 
    s2.p.name = "lisi"; 
    s2.p.age = 30; 
    s2.name = "z"; 
    s2.age = 45; 
    System.out.println(" s1 ：" + s1.name + "
 s1 ：" + s1.p.name + "," + "
 s1 " + s1.p.age);//  1  
  } 
}

s2는 변했지만 s1도 변했다. s1의 p와 s2의 p가 같은 대상을 가리키는 것을 증명한다.이것은 우리가 가지고 있는 실제 수요에서 그렇지 않기 때문에 우리는 깊은 복사를 필요로 한다.

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; 
  } 
} 
 
public class DeepCopy { 
  public static void main(String args[]) { 
    long t1 = System.currentTimeMillis(); 
    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 。 
    long t2 = System.currentTimeMillis(); 
    System.out.println(t2-t1); 
  } 
}

물론 객체를 직렬화하는 심층 복제 방법도 있습니다.

import java.io.*; 
//Serialization is time-consuming 
class Professor2 implements Serializable { 
  /** 
   * 
   */
  private static final long serialVersionUID = 1L; 
  String name; 
  int age; 
 
  Professor2(String name, int age) { 
    this.name = name; 
    this.age = age; 
  } 
} 
 
class Student2 implements Serializable { 
  /** 
   * 
   */
  private static final long serialVersionUID = 1L; 
  String name;//  。 
  int age; 
  Professor2 p;//  1 2 。 
 
  Student2(String name, int age, Professor2 p) { 
    this.name = name; 
    this.age = age; 
    this.p = p; 
  } 
 
  public Object deepClone() throws IOException, OptionalDataException, 
      ClassNotFoundException { 
    //   
    ByteArrayOutputStream 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()); 
  } 
 
} 
 
public class DeepCopy2 { 
 
  /** 
   * @param args 
   */
  public static void main(String[] args) throws OptionalDataException, 
      IOException, ClassNotFoundException { 
    long t1 = System.currentTimeMillis(); 
    Professor2 p = new Professor2("wangwu", 50); 
    Student2 s1 = new Student2("zhangsan", 18, p); 
    Student2 s2 = (Student2) s1.deepClone(); 
    s2.p.name = "lisi"; 
    s2.p.age = 30; 
    System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age); //  1 。 
    long t2 = System.currentTimeMillis(); 
    System.out.println(t2-t1); 
  } 
 
}

그러나 직렬화는 시간이 많이 걸린다. 일부 구조에서 우리는 그들이 종종 대상을 직렬화한 후에 전달하는데 시간이 많이 걸린다는 것을 느낄 수 있다.