2. 程式人生 > >淺談Java中的深拷貝和淺拷貝

淺談Java中的深拷貝和淺拷貝

阿新 • • 發佈：2017-08-24
detail tle pac err @override 復制對象 deep har 間接

　　淺談Java中的深拷貝和淺拷貝（轉載）

原文鏈接：

http://blog.csdn.net/tounaobun/article/details/8491392

假如說你想復制一個簡單變量。很簡單：

[java] view plaincopyprint?
  1. int apples = 5;
  2. int pears = apples; 
		int apples = 5;
		int pears = apples;

不僅僅是int類型，其它七種原始數據類型(boolean,char,byte,short,float,double.long)同樣適用於該類情況。

但是如果你復制的是一個對象，情況就有些復雜了。

假設說我是一個beginner，我會這樣寫：

[java] view plaincopyprint?
  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[]) {
  17. Student stu1 = new Student();
  18. stu1.setNumber(12345);
  19. Student stu2 = stu1;
  21. System.out.println("學生1:" + stu1.getNumber());
  22. System.out.println("學生2:" + stu2.getNumber());
  23. }
  24. } 
class Student {
	private int number;

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	
}
public class Test {
	
	public static void main(String args[]) {
		
		Student stu1 = new Student();
		stu1.setNumber(12345);
		Student stu2 = stu1;
		
		System.out.println("學生1:" + stu1.getNumber());
		System.out.println("學生2:" + stu2.getNumber());
	}
}

打印結果：

[plain] view plaincopyprint?
  1. 學生1:12345
  2. 學生2:12345 
學生1:12345
學生2:12345

這裏我們自定義了一個學生類，該類只有一個number字段。

我們新建了一個學生實例，然後將該值賦值給stu2實例。(Student stu2 = stu1;)

再看看打印結果，作為一個新手，拍了拍胸腹，對象復制不過如此，

難道真的是這樣嗎？

我們試著改變stu2實例的number字段，再打印結果看看：

[java] view plaincopyprint?
  1. stu2.setNumber(54321);
  3. System.out.println("學生1:" + stu1.getNumber());
  4. System.out.println("學生2:" + stu2.getNumber()); 
		stu2.setNumber(54321);
	
		System.out.println("學生1:" + stu1.getNumber());
		System.out.println("學生2:" + stu2.getNumber());

打印結果:

[plain] view plaincopyprint?
  1. 學生1:54321
  2. 學生2:54321 
學生1:54321
學生2:54321

這就怪了，為什麽改變學生2的學號，學生1的學號也發生了變化呢？

原因出在(stu2 = stu1) 這一句。該語句的作用是將stu1的引用賦值給stu2，

這樣，stu1和stu2指向內存堆中同一個對象。如圖：

技術分享

那麽，怎樣才能達到復制一個對象呢？

是否記得萬類之王Object。它有11個方法，有兩個protected的方法，其中一個為clone方法。

該方法的簽名是：

protected native Object clone() throws CloneNotSupportedException;

因為每個類直接或間接的父類都是Object，因此它們都含有clone()方法，但是因為該方法是protected，所以都不能在類外進行訪問。

要想對一個對象進行復制，就需要對clone方法覆蓋。

一般步驟是（淺復制）：

1. 被復制的類需要實現Clonenable接口（不實現的話在調用clone方法會拋出CloneNotSupportedException異常) 該接口為標記接口(不含任何方法)

2. 覆蓋clone()方法，訪問修飾符設為public。方法中調用super.clone()方法得到需要的復制對象，（native為本地方法)

下面對上面那個方法進行改造：

[java] view plaincopyprint?
  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 {
  25. public static void main(String args[]) {
  27. Student stu1 = new Student();
  28. stu1.setNumber(12345);
  29. Student stu2 = (Student)stu1.clone();
  31. System.out.println("學生1:" + stu1.getNumber());
  32. System.out.println("學生2:" + stu2.getNumber());
  34. stu2.setNumber(54321);
  36. System.out.println("學生1:" + stu1.getNumber());
  37. System.out.println("學生2:" + stu2.getNumber());
  38. }
  39. } 
class Student implements Cloneable{
	private int number;

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	
	@Override
	public Object clone() {
		Student stu = null;
		try{
			stu = (Student)super.clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return stu;
	}
}
public class Test {
	
	public static void main(String args[]) {
		
		Student stu1 = new Student();
		stu1.setNumber(12345);
		Student stu2 = (Student)stu1.clone();
		
		System.out.println("學生1:" + stu1.getNumber());
		System.out.println("學生2:" + stu2.getNumber());
		
		stu2.setNumber(54321);
	
		System.out.println("學生1:" + stu1.getNumber());
		System.out.println("學生2:" + stu2.getNumber());
	}
}

打印結果：

[plain] view plaincopyprint?
  1. 學生1:12345
  2. 學生2:12345
  3. 學生1:12345
  4. 學生2:54321 
學生1:12345
學生2:12345
學生1:12345
學生2:54321

如果你還不相信這兩個對象不是同一個對象，那麽你可以看看這一句：

[java] view plaincopyprint?
  1. System.out.println(stu1 == stu2); // false 
		System.out.println(stu1 == stu2); // false

上面的復制被稱為淺復制(Shallow Copy)，還有一種稍微復雜的深度復制(deep copy)：

我們在學生類裏再加一個Address類。

[java] view plaincopyprint?
  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. } 
class Address  {
	private String add;

	public String getAdd() {
		return add;
	}

	public void setAdd(String add) {
		this.add = add;
	}
	
}

class Student implements Cloneable{
	private int number;

	private Address addr;
	
	public Address getAddr() {
		return addr;
	}

	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	
	@Override
	public Object clone() {
		Student stu = null;
		try{
			stu = (Student)super.clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return stu;
	}
}
public class Test {
	
	public static void main(String args[]) {
		
		Address addr = new Address();
		addr.setAdd("杭州市");
		Student stu1 = new Student();
		stu1.setNumber(123);
		stu1.setAddr(addr);
		
		Student stu2 = (Student)stu1.clone();
		
		System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
		System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
	}
}

打印結果：

[plain] view plaincopyprint?
  1. 學生1:123,地址:杭州市
  2. 學生2:123,地址:杭州市 
學生1:123,地址:杭州市
學生2:123,地址:杭州市

乍一看沒什麽問題，真的是這樣嗎？

我們在main方法中試著改變addr實例的地址。

[java] view plaincopyprint?
  1. addr.setAdd("西湖區");
  3. System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
  4. System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd()); 
		addr.setAdd("西湖區");
		
		System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
		System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

打印結果：

[plain] view plaincopyprint?
  1. 學生1:123,地址:杭州市
  2. 學生2:123,地址:杭州市
  3. 學生1:123,地址:西湖區
  4. 學生2:123,地址:西湖區 
學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:西湖區

這就奇怪了，怎麽兩個學生的地址都改變了？

原因是淺復制只是復制了addr變量的引用，並沒有真正的開辟另一塊空間，將值復制後再將引用返回給新對象。

所以，為了達到真正的復制對象，而不是純粹引用復制。我們需要將Address類可復制化，並且修改clone方法，完整代碼如下：

[java] view plaincopyprint?
  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. } 
package abc;

class Address implements Cloneable {
	private String add;

	public String getAdd() {
		return add;
	}

	public void setAdd(String add) {
		this.add = add;
	}
	
	@Override
	public Object clone() {
		Address addr = null;
		try{
			addr = (Address)super.clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return addr;
	}
}

class Student implements Cloneable{
	private int number;

	private Address addr;
	
	public Address getAddr() {
		return addr;
	}

	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	
	@Override
	public Object clone() {
		Student stu = null;
		try{
			stu = (Student)super.clone();	//淺復制
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		stu.addr = (Address)addr.clone();	//深度復制
		return stu;
	}
}
public class Test {
	
	public static void main(String args[]) {
		
		Address addr = new Address();
		addr.setAdd("杭州市");
		Student stu1 = new Student();
		stu1.setNumber(123);
		stu1.setAddr(addr);
		
		Student stu2 = (Student)stu1.clone();
		
		System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
		System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
		
		addr.setAdd("西湖區");
		
		System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
		System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
	}
}

打印結果：

[plain] view plaincopyprint?
  1. 學生1:123,地址:杭州市
  2. 學生2:123,地址:杭州市
  3. 學生1:123,地址:西湖區
  4. 學生2:123,地址:杭州市 
學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:杭州市

這樣結果就符合我們的想法了。

總結：淺拷貝是指在拷貝對象時，對於基本數據類型的變量會重新復制一份，而對於引用類型的變量只是對引用進行拷貝，

沒有對引用指向的對象進行拷貝。

而深拷貝是指在拷貝對象時，同時會對引用指向的對象進行拷貝。

區別就在於是否對 對象中的引用變量所指向的對象進行拷貝。

最後我們可以看看API裏其中一個實現了clone方法的類：

java.util.Date:

[java] view plaincopyprint?
  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. } 
    /**
     * Return a copy of this object.
     */
    public Object clone() {
        Date d = null;
        try {
            d = (Date)super.clone();
            if (cdate != null) {
                d.cdate = (BaseCalendar.Date) cdate.clone();
            }
        } catch (CloneNotSupportedException e) {} // Won‘t happen
        return d;
    }

該類其實也屬於深度復制。

淺談Java中的深拷貝和淺拷貝

相關推薦

淺談Java中的物件和物件的引用

淺談java中的物件和引用 文章轉載出處：https://www.cnblogs.com/dolphin0520/p/3592498.html 在Java中，有一組名詞經常一起出現，它們就是“物件和物件引用”，很多朋友在初學Java的時候可能經常會混淆這2個概念，覺得它們是一回事，事

【java筆記】淺談Java中的equals和==

在初學Java時，可能會經常碰到下面的程式碼： String str1 = new String("hello"); String str2 = new String("hello"); System.out.println(str1==str2); System.out.

淺談Java中的物件和引用

Java物件及其引用  原文：http://zwmf.iteye.com/blog/1738574 關於物件與引用之間的一些基本概念。         初學Java時，在很長一段時間裡，總覺得基本概念很模糊。後來才知道，在許多Java書中，把物件和物件的引用混為一談。可是，

淺談Java中的equals和==(轉)

本文轉自：https://www.cnblogs.com/dolphin0520/p/3592500.html 在初學Java時，可能會經常碰到下面的程式碼： 1 String str1 = new String("hello"); 2 String str2 = new String("hel

淺談Java中的棧和堆

== 寫在前面 首地址 n) char 即使 作用 ble 堆和棧 人們常說堆棧堆棧，堆和棧是內存中兩處不一樣的地方，什麽樣的數據存在棧，又是什麽樣的數據存在堆中？ 這裏淺談Java中的棧和堆 首先，將結論寫在前面，後面再用例子加以驗證。 Java的棧中存儲以下類型數據

淺談物件的深複製和淺複製的區別。

  場景   當你的元件裡需要用到同一個資料，但身負不同的責任。   舉個例子：vue的雙向繫結   你在與後端的互動中請求回來的資料，res,  let a = res; let b = res; 　因為是會用到checkbox，在外層的列表裡選中資

淺談Java中的深拷貝和淺拷貝

detail tle pac err @override 復制對象 deep har 間接 　　淺談Java中的深拷貝和淺拷貝（轉載） 原文鏈接： http://blog.csdn.net/tounaobun/article/details/8491392 假如說你想復制一

淺談java中的淺拷貝（淺複製）和深拷貝（深複製）

淺拷貝： 淺拷貝又稱為淺複製，淺克隆，淺拷貝是指拷貝時只拷貝物件本身（包括物件中的基本變數），而不拷貝物件包含的引用所指向的物件，拷貝出來的物件的所有變數的值都含有與原來物件相同的值，而所有對其他物件的引用都指向原來的物件，簡單地說，淺拷貝只拷貝物件不拷貝引用

淺談java中的"=="和eqals區別

short copy 覆寫 main 否則 變量 程序 bar gif 在初學Java時，可能會經常碰到下面的代碼： 1 String str1 = new String("hello"); 2 String str2 = new String("hello");

淺談java中"&&"和"&"的區別

“&&”和”&”都是java中的邏輯運算子，並且它們都表示“邏輯與”即“同真則真，有一假則假”，它們的區別在於”&&”具有短路功能，即如果左邊是false，則右邊的邏輯表示式不會執行。而”&”沒有短路功能，無論左邊是false還是true右邊都會執行。

淺談Java中物件的==、equals和hashCode

目錄 運算子 == equals() String中的equals() Integer中的equals() Long中equals() hashCode() 運算子 == Java中的==是比較兩

淺談java中的值型別和引用型別

1、值型別 （1）也就是基本的資料型別分為：四類八種 （2）四類：整型、浮點型、字元型、布林型 （3）八種：整型4種--byte、short、int、long              浮點型2種--float、double    字元型：char        

淺談java中OO的概念和設計原則(必看)

一．OO(面向物件)的設計基礎 面向物件(OO)：就是基於物件概念，以物件為中心，以類和繼承為構造機制，充分利用介面和多型提供靈活性，來認識、理解、刻劃客觀世界和設計、構建相應的軟體系統。面向物件的特徵：雖然各種面向物件程式語言相互有別，但都能看到它們對面向物件基本特徵的支援， 即 “抽象、

淺談JAVA中類和物件的理解

   我們知道程式語言是一個幫助我們和計算機“對話”的工具，我們可以通過它去讓計算機做一些事。而JAVA語言又是其中的高階語言，那麼什麼是高階？機器語言和人類語言之間有著巨大的鴻溝，人們不斷的想要跨過這個鴻溝，在這個過程中出現了一些“工具”，就是所謂的程式語言。通過這些語言

淺談java中replace()和replaceAll()的區別

replace和replaceAll是JAVA中常用的替換字元的方法,它們的區別是： 1)replace的引數是char和CharSequence，即可以支援字元的替換，也支援字串的替換(CharSequence即字串序列的意思,說白了也就是字串)； 2)replaceA

淺談Java中的hashCode方法

implement state ask get() 存在 rsa key 沖突 如何 哈希表這個數據結構想必大多數人都不陌生，而且在很多地方都會利用到hash表來提高查找效率。在Java的Object類中有一個方法: public native int hashCode(

淺談java內存分配和回收策略

內存空間 高效率 cde map details 閾值 老年代 total 關於 一、導論 　　java技術體系中所提到的內存自動化管理歸根結底就是內存的分配與回收兩個問題，之前已經和大家談過java回收的相關知識，今天來和大家聊聊java對象的在內存中的分配。通俗的講，對

淺談AngularJS中的$parse和$eval

淺談 return 什麽是 apply() logs ava new 表達式 ret AngularJS的初學者常常會對$parse和$eval兩個內建服務感到有些困惑，今天我們就來說說AngularJS中的$parse和$eval。 總的來說，$parse和$eval都

淺談AngularJS中的指令和指令間的相互通信

file str 裏的 按鈕 相互 要去 direct 不能 pil 說到AngularJS，我們首先想到的大概也就是雙向數據綁定和指令系統了，這兩者也是AngularJS中最為吸引人的地方。雙向數據綁定呢，感覺沒什麽好說的，那麽今天我們就來簡單的討論下AngularJS這

淺談java中內置的觀察者模式與動態代理的實現

所有 代理 notify play ani effect 一個 indicate protected 一.關於觀察者模式 1.將觀察者與被觀察者分離開來，當被觀察者發生變化時，將通知所有觀察者，觀察者會根據這些變化做出對應的處理。 2.jdk裏已經提供對應的Observer