程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> Java中的深拷貝(深復制)和淺拷貝(淺復制)引見

Java中的深拷貝(深復制)和淺拷貝(淺復制)引見

編輯：關於JAVA

Java中的深拷貝(深復制)和淺拷貝(淺復制)引見。本站提示廣大學習愛好者：（Java中的深拷貝(深復制)和淺拷貝(淺復制)引見）文章只能為提供參考，不一定能成為您想要的結果。以下是Java中的深拷貝(深復制)和淺拷貝(淺復制)引見正文

深拷貝(深復制)和淺拷貝(淺復制)是兩個比擬通用的概念，特別在C++說話中，若不弄懂，則會在delete的時刻出成績，然則我們在這幸虧用的是Java。固然java主動治理對象的收受接管，但關於深拷貝(深復制)和淺拷貝(淺復制)，我們照樣要賜與足夠的看重，由於有時這兩個概念常常會給我們帶來不小的迷惑。

淺拷貝是指拷貝對象時僅僅拷貝對象自己（包含對象中的根本變量），而不拷貝對象包括的援用指向的對象。深拷貝不只拷貝對象自己，並且拷貝對象包括的援用指向的一切對象。舉例來講加倍清晰：對象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 + "\n先生s1傳授的姓名：" + s1.p.name + "," + "\n先生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); 
  } 
 
}

然則串行化卻很耗時，在一些框架中，我們即可以感觸感染到，它們常常將對象停止串行化落後行傳遞，耗時較多。

關於JAVA