2. 程式人生 > >JAVA中的深復制和淺復制--建議多看幾遍

JAVA中的深復制和淺復制--建議多看幾遍

阿新 • • 發佈：2018-01-25
substring 例如 pack eval new 數據類型 goto ava public

轉載：https://www.cnblogs.com/avivahe/p/5710945.html

Java 語言的一個優點就是取消了指針的概念，但也導致了許多程序員在編程中常常忽略了對象與引用的區別，本文會試圖澄清這一概念。並且由於Java不能通過簡單 的賦值來解決對象復制的問題，在開發過程中，也常常要要應用clone（）方法來復制對象。本文會讓你了解什麽是影子clone與深度clone，認識它 們的區別、優點及缺點。

看到這個標題，是不是有點困惑：Java語 言明確說明取消了指針，因為指針往往是在帶來方便的同時也是導致代碼不安全的根源，同時也會使程序的變得非常復雜難以理解，濫用指針寫成的代碼不亞於使用 早已臭名昭著的"GOTO"語句。Java放棄指針的概念絕對是極其明智的。但這只是在Java語言中沒有明確的指針定義，實質上每一個new語句返回的 都是一個指針的引用，只不過在大多時候Java中不用關心如何操作這個"指針"，更不用象在操作C＋＋的指針那樣膽戰心驚。唯一要多多關心的是在給函數傳 遞對象的時候。

package com.zoer.src;

public class Obj {

    String str = "init value";

    public String toString() {
        return str;
    }
}
package com.zoer.src;

public class ObjRef {
    Obj aObj = new Obj();
    int aInt = 11;

    public void changeObj(Obj inObj) {
        inObj.str = "changed value";
    }

    
 
public void changePri(int inInt) {
        inInt = 22;
    }

    public static void main(String[] args) {
        ObjRef oRef = new ObjRef();

        System.out.println("Before call changeObj() method: " + oRef.aObj);
        oRef.changeObj(oRef.aObj);
        System.out.println("After call changeObj() method: " + oRef.aObj);

        System.out.println(
 
"==================Print Primtive=================");
        System.out.println("Before call changePri() method: " + oRef.aInt);
        oRef.changePri(oRef.aInt);
        System.out.println("After call changePri() method: " + oRef.aInt);

    }
}

這段代碼的主要部分調用了兩個很相近的方法，changeObj()和changePri()。唯一不同的是它們一個把對象作為輸入參數，另一個把 Java中的基本類型int作為輸入參數。並且在這兩個函數體內部都對輸入的參數進行了改動。看似一樣的方法，程序輸出的結果卻不太一樣。 changeObj()方法真正的把輸入的參數改變了，而changePri()方法對輸入的參數沒有任何的改變。

從這個例子知道Java對對象和基本的數據類型的處理是不一樣的。和C語言一樣，當把Java的基本數據類型（如int，char，double等）作為入口參數傳給函數體的時候，傳入的參數在函數體內部變成了局部變量，這個局部變量是輸入參數的一個拷貝，所有的函數體內部的操作都是針對這個拷貝的操作，函數執行結束後，這個局部變量也就完成了它的使命，它影響不到作為輸入參數的變量。這種方式的參數傳遞被稱為"值傳遞"。而在Java中用對象作為入口參數的傳遞則缺省為"引用傳遞"，也就是說僅僅傳遞了對象的一個"引用"，這個"引用"的概念同C語言中的指針引用是一樣的。當函數體內部對輸入變量改變時，實質上就是在對這個對象的直接操作。

除了在函數傳值的時候是"引用傳遞"，在任何用"＝"向對象變量賦值的時候都是"引用傳遞"。就是類似於給變量再起一個別名。兩個名字都指向內存中的同一個對象。
在實際編程過程中，我們常常要遇到這種情況：有一個對象A，在某一時刻A中已經包含了一些有效值，此時可能會需要一個和A完全相同新對象B，並且此後對B任何改動都不會影響到A中的值，也就是說，A與B是兩個獨立的對象，但B的初始值是由A對象確定的。在Java語言中，用簡單的賦值語句是不能滿足這種需求的。要滿足這種需求雖然有很多途徑，但實現clone（）方法是其中最簡單，也是最高效的手段。
Java的所有類都默認繼承java.lang.Object類，在java.lang.Object類中有一個方法clone()。JDK API的說 明文檔解釋這個方法將返回Object對象的一個拷貝。要說明的有兩點：一是拷貝對象返回的是一個新對象，而不是一個引用。二是拷貝對象與用new操作符 返回的新對象的區別就是這個拷貝已經包含了一些原來對象的信息，而不是對象的初始信息。
怎樣應用clone()方法？

一個很典型的調用clone()代碼如下： 

public class CloneClass implements Cloneable {
    public int aInt;

    public Object clone() {
        CloneClass o = null;
        try {
            o = (CloneClass) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

有三個值得註意的地方，一是希望能實現clone功能的CloneClass類實現了Cloneable接口，這個接口屬於java.lang 包，java.lang包已經被缺省的導入類中，所以不需要寫成java.lang.Cloneable。另一個值得請註意的是重載了clone()方 法。最後在clone()方法中調用了super.clone()，這也意味著無論clone類的繼承結構是什麽樣的，super.clone()直接或間接調用了java.lang.Object類的clone()方法。下面再詳細的解釋一下這幾點。 應該說第三點是最重要的，仔細觀察一下Object類的clone()一個native方法，native方法的效率一般來說都是遠高於java中的非native方法。這也解釋了為什麽要用Object中clone()方法而不是先new一個類，然後把原始對象中的信息賦到新對象中，雖然這也實現了clone功能。對於第二點，也要觀察Object類中的clone()還是一個protected屬 性的方法。這也意味著如果要應用clone()方法，必須繼承Object類，在Java中所有的類是缺省繼承Object類的，也就不用關心這點了。然 後重載clone()方法。還有一點要考慮的是為了讓其它類能調用這個clone類的clone()方法，重載之後要把clone()方法的屬性設置為public。
那麽clone類為什麽還要實現Cloneable接口呢？稍微註意一下，Cloneable接口是不包含任何方法的！其實這個接口僅僅是一個標誌，而 且這個標誌也僅僅是針對Object類中clone()方法的，如果clone類沒有實現Cloneable接口，並調用了Object的clone() 方法（也就是調用了super.Clone()方法），那麽Object的clone()方法就會拋出 CloneNotSupportedException異常。
以上是clone的最基本的步驟，想要完成一個成功的clone，還要了解什麽是"影子clone"和"深度clone"。
什麽是影子clone？ 

package com.zoer.src;

class UnCloneA {
    private int i;

    public UnCloneA(int ii) {
        i = ii;
    }

    public void doublevalue() {
        i *= 2;
    }

    public String toString() {
        return Integer.toString(i);
    }
}

class CloneB implements Cloneable {
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);

    public Object clone() {
        CloneB o = null;
        try {
            o = (CloneB) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

public class ObjRef {
    public static void main(String[] a) {
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = " + b1.aInt);
        System.out.println("before clone,b1.unCA = " + b1.unCA);

        CloneB b2 = (CloneB) b1.clone();
        b2.aInt = 22;
        b2.unCA.doublevalue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = " + b1.aInt);
        System.out.println("after clone,b1.unCA = " + b1.unCA);
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = " + b2.aInt);
        System.out.println("after clone,b2.unCA = " + b2.unCA);
    }
}

輸出結果：

before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 222
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222

輸出的結果說明int類型的變量aInt和UnCloneA的實例對象unCA的clone結果不一致，int類型是真正的被clone了，因為改變了 b2中的aInt變量，對b1的aInt沒有產生影響，也就是說，b2.aInt與b1.aInt已經占據了不同的內存空間，b2.aInt是 b1.aInt的一個真正拷貝。相反，對b2.unCA的改變同時改變了b1.unCA，很明顯，b2.unCA和b1.unCA是僅僅指向同一個對象的不同引用！從中可以看出，調用Object類中clone()方法產生的效果是：先在內存中開辟一塊和原始對象一樣的空間，然後原樣拷貝原始對象中的內容。對基本數據類型，這樣的操作是沒有問題的，但對非基本類型變量，我們知道它們保存的僅僅是對象的引用，這也導致clone後的非基本類型變量和原始對象中相應的變量指向的是同一個對象。

大多時候，這種clone的結果往往不是我們所希望的結果，這種clone也被稱為"影子clone"。要想讓b2.unCA指向與b2.unCA不同的對象，而且b2.unCA中還要包含b1.unCA中的信息作為初始信息，就要實現深度clone。
怎麽進行深度clone？
把上面的例子改成深度clone很簡單，需要兩個改變：一是讓UnCloneA類也實現和CloneB類一樣的clone功能（實現Cloneable 接口，重載clone()方法）。二是在CloneB的clone()方法中加入一句 o.unCA = (UnCloneA)unCA.clone(); 

package com.zoer.src;

class UnCloneA implements Cloneable {
    private int i;

    public UnCloneA(int ii) {
        i = ii;
    }

    public void doublevalue() {
        i *= 2;
    }

    public String toString() {
        return Integer.toString(i);
    }

    public Object clone() {
        UnCloneA o = null;
        try {
            o = (UnCloneA) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}

class CloneB implements Cloneable {
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);

    public Object clone() {
        CloneB o = null;
        try {
            o = (CloneB) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        o.unCA = (UnCloneA) unCA.clone();
        return o;
    }
}

public class CloneMain {
    public static void main(String[] a) {
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = " + b1.aInt);
        System.out.println("before clone,b1.unCA = " + b1.unCA);

        CloneB b2 = (CloneB) b1.clone();
        b2.aInt = 22;
        b2.unCA.doublevalue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = " + b1.aInt);
        System.out.println("after clone,b1.unCA = " + b1.unCA);
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = " + b2.aInt);
        System.out.println("after clone,b2.unCA = " + b2.unCA);
    }
}

輸出結果：

before clone,b1.aInt = 11
before clone,b1.unCA = 111
=================================
after clone,b1.aInt = 11
after clone,b1.unCA = 111
=================================
after clone,b2.aInt = 22
after clone,b2.unCA = 222

可以看出，現在b2.unCA的改變對b1.unCA沒有產生影響。此時b1.unCA與b2.unCA指向了兩個不同的UnCloneA實例，而且在 CloneB b2 = (CloneB)b1.clone();調用的那一刻b1和b2擁有相同的值，在這裏，b1.i = b2.i = 11。

要知道不是所有的類都能實現深度clone的。例如，如果把上面的CloneB類中的UnCloneA類型變量改成StringBuffer類型，看一下JDK API中關於StringBuffer的說明，StringBuffer沒有重載clone()方法，更為嚴重的是StringBuffer還是一個final類， 這也是說我們也不能用繼承的辦法間接實現StringBuffer的clone。如果一個類中包含有StringBuffer類型對象或和 StringBuffer相似類的對象，我們有兩種選擇：要麽只能實現影子clone，要麽就在類的clone()方法中加一句（假設是 SringBuffer對象，而且變量名仍是 unCA）： o.unCA = new StringBuffer(unCA.toString()); //原來的 是：o.unCA = (UnCloneA)unCA.clone();

還要知道的是除了基本數據類型能自動實現深度clone以外，String對象是一個例外，它clone後的表現好象也實現了深度clone，雖然這只是一個假象，但卻大大方便了我們的編程。
Clone中String和StringBuffer的區別
應該說明的是，這裏不是著重說明String和StringBuffer的區別，但從這個例子裏也能看出String類的一些與眾不同的地方。
下面的例子中包括兩個類，CloneC類包含一個String類型變量和一個StringBuffer類型變量，並且實現了clone()方法。在 StrClone類中聲明了CloneC類型變量c1，然後調用c1的clone()方法生成c1的拷貝c2，在對c2中的String和 StringBuffer類型變量用相應的方法改動之後打印結果： 

package com.zoer.src;

class CloneC implements Cloneable {
    public String str;
    public StringBuffer strBuff;

    public Object clone() {
        CloneC o = null;
        try {
            o = (CloneC) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

}

public class StrClone {
    public static void main(String[] a) {
        CloneC c1 = new CloneC();
        c1.str = new String("initializeStr");
        c1.strBuff = new StringBuffer("initializeStrBuff");
        System.out.println("before clone,c1.str = " + c1.str);
        System.out.println("before clone,c1.strBuff = " + c1.strBuff);

        CloneC c2 = (CloneC) c1.clone();
        c2.str = c2.str.substring(0, 5);
        c2.strBuff = c2.strBuff.append(" change strBuff clone");
        System.out.println("=================================");
        System.out.println("after clone,c1.str = " + c1.str);
        System.out.println("after clone,c1.strBuff = " + c1.strBuff);
        System.out.println("=================================");
        System.out.println("after clone,c2.str = " + c2.str);
        System.out.println("after clone,c2.strBuff = " + c2.strBuff);
    }
}

執行結果：

[java] view plain copy
  1. <span style="font-family:‘Microsoft YaHei‘;"><span style="font-size:16px;">before clone,c1.str = initializeStr
  2. before clone,c1.strBuff = initializeStrBuff
  3. =================================
  4. after clone,c1.str = initializeStr
  5. after clone,c1.strBuff = initializeStrBuff change strBuff clone
  6. =================================
  7. after clone,c2.str = initi
  8. after clone,c2.strBuff = initializeStrBuff change strBuff clone
  9. </span></span>

打印的結果可以看出，String類型的變量好象已經實現了深度clone，因為對c2.str的改動並沒有影響到c1.str！難道Java把 Sring類看成了基本數據類型？其實不然，這裏有一個小小的把戲，秘密就在於c2.str = c2.str.substring(0,5)這一語句！ 實質上，在clone的時候c1.str與c2.str仍然是引用，而且都指向了同一個String對象。但在執行 c2.str = c2.str.substring(0,5)的時候，它作用相當於生成了一個新的String類型，然後又賦回給c2.str。這是因 為String被Sun公司的工程師寫成了一個不可更改的類（immutable class），在所有String類中的函數都不能更改自身的值。

技術分享圖片

  • duxingxia_007

    2013-03-29 16:112樓 回復
  • 這個代碼說明這篇文章指出的說java中默認的對對象是引用傳遞是錯誤的，java中只有值傳遞。
    • 回復
    • [java] view plain copy
      1. public static void main(String[] args){
      2. Integer[] a={1,2};
      3. add(a);
      4. System.out.println(a[0]+" "+a[1]);
      5. }
      6. static void add(Integer[] a)
      7. {
      8. a=null;
      9. //return a;
      10. }

      結果是可以正常輸出a，並沒有成為null。
技術分享圖片

  • naughty610

    2013-03-30 11:42
  • 回復duxingxia_007：謝謝您的回復。我說說我的理解。我還是認為java對於對象來說是傳遞引用的。不知道你看過jvm的書籍沒有？在jvm操作數棧上，除了可以放置基本類型之外，還可以有一個類型就是“引用類型”。這裏說的引用，與你貼出來的那個英文網站說的pointer，應該是指的同一個意思了。都是指向了堆中的對象。
    至於你舉的例子，我有如下理解：
    你在main函數中，初始化了一個數組，然後用a引用這個數組。調用add函數的時候，傳遞a這個引用進去了。然後在add中把a置為null。【這是你代碼的過程】
    但是main函數在jvm中占用一個虛擬機棧幀，對於add函數，這在jvm中又是另外一個虛擬機棧幀了（add這個棧幀是因為調用函數引起的）。在原來main函數中，操作數棧中有a這個引用。在add函數的這個棧幀中，也是存在一個引用最初的Integer數組的引用，我們稱之為aa。請註意，aa和a是不同的引用了。他們存在於兩個操作數棧中（雖然他們都引用了同一個數組對象）。所以在add函數中，你讓a=null，實際上是讓aa這個引用不再引用其他對象。但是這並沒有改變main函數操作數棧中a的引用。main函數操作數棧中a還是引用那個數組對象的。
    上面是全部解釋。這就是為什麽你代碼得到了你說的那個結果。
    ------------
    不知道我說的對不對。希望指正。
    -----------
    最後再補充一句。那個英文網址，說的傳遞指針，實際上在我的理解裏，就是我這裏說的引用。。

JAVA中的深復制和淺復制--建議多看幾遍

相關推薦

JAVA中的深復制和淺復制--建議多看幾遍

substring 例如 pack eval new 數據類型 goto ava public 轉載：https://www.cnblogs.com/avivahe/p/5710945.html Java 語言的一個優點就是取消了指針的概念，但也導致了許多程序員在編程中常常

python 字典深復制和淺復制

python 淺復制 root 進行 deep 打印 use 也會 odin #!/usr/bin/python# -*- coding: UTF-8 -*-import copydict1 = {‘user‘: ‘vickey‘, ‘num‘: [1, 2, 3],‘ag

C++深復制和淺復制

C++對於普通類型的對象來說，它們之間的復制是很簡單的，例如：int a=88; int b=a; double f=3.12; double d(f); 而類對象與普通對象不同，類對象內部結構一般較為復雜，存在各種數據成員。 #include <iostream> using na

RESTful轉載，多看幾遍就理解了寫點自己的看法和理解

類型 delete 標識 class 請求 source 通用 添加 架構 要理解資源路由就要理解什麽是RESTful。如果一個架構符合REST（即Representational State Transfer的縮寫，意為表現層狀態轉化）原則，就稱它為RESTful架構。

java學習乾貨分享，從小白到年薪50萬（建議收藏多看幾遍）

今天準備來點乾貨，因此咱們就不說一些學習方法和技巧了，直接來談每個階段要學習的內容甚至是一些書籍。這一部分的內容，同樣適用於一些希望轉行到Java的同學。文章寫的有點長，可以收藏或關注我，以便深入瞭解和學習。（PS:全文共5000多字，各位同學通過收藏或關注作者，慢慢細讀學習，同時也可以發表

Spark中的Spark Shuffle詳解(多看幾遍)

Shuffle簡介 Shuffle描述著資料從map task輸出到reduce task輸入的這段過程。shuffle是連線Map和Reduce之間的橋樑，Map的輸出要用到Reduce中必須經過shuffle這個環節，shuffle的效能高低直接影響了整個程式的效能和吞吐量。因為在分散式情況

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

alt public min import containe long serializa port nbsp 深拷貝(深復制)和淺拷貝(淺復制)是兩個比較通用的概念，尤其在C++語言中，若不弄懂，則會在delete的時候出問題，但是我們在這幸好用的是Java。雖然java

Java的clone()：深復制與淺復制

super nbsp pan return 定義類 pub ESS cep 基本 Java中要想自定義類的對象可以被復制，自定義類就必須實現Cloneable中的clone()方法，如下： 1 public class Student implements Clone

js的深復制與淺復制

color 更改 obj arr bsp asc 存儲 字符 同時 什麽是深復制和淺復制？ 　　深復制和淺復制的概念只存在於對象array和數組obj上。 　　淺復制是：模糊復制，就是不管對方是字符串類型還是引用類型都通通復制過來。結果兩個變量的內容會同時變化。 　　深復制

Angular JS 中 ng-controller 值復制和引用復制

span tro strong bar del ng- scope value 變化 我們知道在使用ng-app或者ng-controller指令的時候，都會創建一個新的作用域（$rootScope或者是$scope），並且在使用ng-controller指令創建的作用域會

Java中深拷貝和淺拷貝(deepcopy和shallowcopy)

原型模式要求用深拷貝(複製/克隆)的方式實現，對這個概念很模糊。在自己查了相關資料後，我將從三個方面講述深淺拷貝： 圖形表述深淺拷貝區別及特點 Object類中的clone()方法實現深淺拷貝 實際應用中深淺拷貝區別 一 圖形表述深淺拷貝區別及特點 前提：深淺拷貝基本

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

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

MySQL傳統復制和GTID復制參考

password mysqldump base -s blog info -a exec cat 1.mysqldump或者xtrabackup導出數據庫scp到需要需要的備庫上，然後倒入到數據庫中，本例子使用mysqldump，xtrabacup請參考另外博客http:/

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

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

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

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

Java中實現String.padLeft和String.padRight

toc 還要 color for 失去 1-1 arraycopy ace pre 因為習慣了C#中的padLeft和padRight，接觸Java後突然失去這兩個功能，覺得別扭，就試著實現了這兩個方法。 Java中String.format()中帶有字符串對齊功能如下

理解Java中的引用傳遞和值傳遞

包裝類 pri ble buffer 聲明 change cnblogs padding ber 關於Java傳參時是引用傳遞還是值傳遞，一直是一個討論比較多的話題，有論壇說Java中只有值傳遞，也有些地方說引用傳遞和值傳遞都存在，比較容易讓人迷惑。關於值傳遞和引用傳遞其

Java中靜態變量和動態變量

.com pan 1-1 一道 args ict print stat 類的加載 這是我面試遇到的一道題，題目如下： 1 public class StaticTest { 2 private static int b = 1; 3 priv

JAVA中 成員變量和和實例變量區別

protected ket 成員變量 訪問修飾符 lena idt variable 類型 多少 java語言支持的變量類型 類變量：獨立於方法之外的變量，用 static 修飾。 局部變量：類的方法中的變量。 實例變量（全局變量）：獨立於方法之外的變量，不過沒有 sta

Java字節數組和16進制字符串的互相轉化

格式 這樣的 req 而且 har 想想 .net string類 pan 背景基礎知識： 1、字符編碼的相關知識（轉自http://blog.csdn.net/llwan/article/details/7567906） 1.1、 “字符”是由數字來表示的 先來重新了解一