5張圖搞懂Java引用拷貝、淺拷貝、深拷貝

語言: CN / TW / HK

微信搜一搜 「bigsai」 關注這個專注於Java和數據結構與算法的鐵鐵 文章收錄在github/bigsai-algorithm 歡迎star收藏 如果本篇對你有幫助,記得點贊收藏哦!

在開發、刷題、面試中,我們可能會遇到將一個對象的屬性賦值到另一個對象的情況,這種情況就叫做拷貝。拷貝與Java內存結構息息相關,搞懂Java深淺拷貝是很必要的!

在對象的拷貝中,很多初學者可能搞不清到底是拷貝了引用還是拷貝了對象。在拷貝中這裏就分為引用拷貝、淺拷貝、深拷貝進行講述。

引用拷貝

引用拷貝會生成一個新的對象引用地址,但是兩個最終指向依然是同一個對象。如何更好的理解引用拷貝呢?很簡單,就拿我們人來説,通常有個姓名,但是不同場合、人物對我們的叫法可能不同,但我們很清楚哪些名稱都是屬於"我"的!

image-20201216222353944

當然,通過一個代碼示例讓大家領略一下(為了簡便就不寫get、set等方法):

class Son {
    String name;
    int age;

    public Son(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class test {
    public static void main(String[] args) {
        Son s1 = new Son("son1", 12);
        Son s2 = s1;
        s1.age = 22;
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("s1的age:" + s1.age);
        System.out.println("s2的age:" + s2.age);
        System.out.println("s1==s2" + (s1 == s2));//相等
    }
}
複製代碼

輸出的結果為:

Son@135fbaa4
Son@135fbaa4
s1的age:22
s2的age:22
true
複製代碼

淺拷貝

如何創建一個對象,將目標對象的內容複製過來而不是直接拷貝引用呢?

這裏先講一下淺拷貝,淺拷貝會創建一個新對象,新對象和原對象本身沒有任何關係,新對象和原對象不等,但是新對象的屬性和老對象相同。具體可以看如下區別:

  • 如果屬性是基本類型(int,double,long,boolean等),拷貝的就是基本類型的值;

  • 如果屬性是引用類型,拷貝的就是內存地址(即複製引用但不復制引用的對象) ,因此如果其中一個對象改變了這個地址,就會影響到另一個對象。

如果用一張圖來描述一下淺拷貝,它應該是這樣的:

image-20201217002917565

如何實現淺拷貝呢?也很簡單,就是在需要拷貝的類上實現Cloneable接口並重寫其clone()方法

@Override
protected Object clone() throws CloneNotSupportedException {
  return super.clone();
}
複製代碼

在使用的時候直接調用類的clone()方法即可。具體案例如下:

class Father{
    String name;
    public Father(String name) {
        this.name=name;
    }
    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Son implements Cloneable {
    int age;
    String name;
    Father father;
    public Son(String name,int age) {
        this.age=age;
        this.name = name;
    }
    public Son(String name,int age, Father father) {
        this.age=age;
        this.name = name;
        this.father = father;
    }
    @Override
    public String toString() {
        return "Son{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", father=" + father +
                '}';
    }
    @Override
    protected Son clone() throws CloneNotSupportedException {
        return (Son) super.clone();
    }
}
public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Father f=new Father("bigFather");
        Son s1 = new Son("son1",13);
        s1.father=f;
        Son s2 = s1.clone();
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("s1==s2:"+(s1 == s2));//不相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
        System.out.println();

        //但是他們的Father father 和String name的引用一樣
        s1.age=12;
        s1.father.name="smallFather";//s1.father引用未變
        s1.name="son222";//類似 s1.name=new String("son222") 引用發生變化
        System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
        System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
        System.out.println(s1);
        System.out.println(s2);
    }
}
複製代碼

運行結果為:

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:true//此時相等

s1.Father==s2.Father:true
s1.name==s2.name:false//修改引用後不等
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='smallFather'}}
複製代碼

不出意外,這種淺拷貝除了對象本身不同以外,各個零部件和關係和拷貝對象都是相同的,就好像雙胞胎一樣,是兩個人,但是其開始的樣貌、各種關係(父母親人)都是相同的。需要注意的是其中name初始==是相等的,是因為初始淺拷貝它們指向一個相同的String,而後 s1.name="son222" 則改變引用指向。

image-20201217103648400

深拷貝

對於上述的問題雖然拷貝的兩個對象不同,但其內部的一些引用還是相同的,怎麼樣絕對的拷貝這個對象,使這個對象完全獨立於原對象呢?就使用我們的深拷貝了。深拷貝:在對引用數據類型進行拷貝的時候,創建了一個新的對象,並且複製其內的成員變量。

image-20201217111300466

在具體實現深拷貝上,這裏提供兩個方式,重寫clone()方法和序列法。

重寫clone()方法

如果使用重寫clone()方法實現深拷貝,那麼要將類中所有自定義引用變量的類也去實現Cloneable接口實現clone()方法。對於字符類可以創建一個新的字符串實現拷貝。

對於上述代碼,Father類實現Cloneable接口並重寫clone()方法。son的clone()方法需要對各個引用都拷貝一遍

//Father clone()方法
@Override
protected Father clone() throws CloneNotSupportedException {
    return (Father) super.clone();
}
//Son clone()方法
@Override
protected Son clone() throws CloneNotSupportedException {
    Son son= (Son) super.clone();//待返回克隆的對象
    son.name=new String(name);
    son.father=father.clone();
    return son;
}
複製代碼

其他代碼不變,執行結果如下:

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:false

s1.Father==s2.Father:false
s1.name==s2.name:false
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
複製代碼
序列化

可以發現這種方式實現了深拷貝。但是這種情況有個問題,如果引用數量或者層數太多了怎麼辦呢?

image-20201217105458651

不可能去每個對象挨個寫clone()吧?那怎麼辦呢?藉助序列化啊。

因為序列化後:將二進制字節流內容寫到一個媒介(文本或字節數組),然後是從這個媒介讀取數據,原對象寫入這個媒介後拷貝給clone對象,原對象的修改不會影響clone對象,因為clone對象是從這個媒介讀取。

熟悉對象緩存的知道我們經常將Java對象緩存到Redis中,然後還可能從Redis中讀取生成Java對象,這就用到序列化和反序列化。一般可以將Java對象存儲為字節流或者json串然後反序列化成Java對象。因為序列化會儲存對象的屬性但是不會也無法存儲對象在內存中地址相關信息。所以在反序列化成Java對象時候會重新創建所有的引用對象。

在具體實現上,自定義的類需要實現Serializable接口。在需要深拷貝的類(Son)中定義一個函數返回該類對象:

protected Son deepClone() throws IOException, ClassNotFoundException {
      Son son=null;
      //在內存中創建一個字節數組緩衝區,所有發送到輸出流的數據保存在該字節數組中
      //默認創建一個大小為32的緩衝區
      ByteArrayOutputStream byOut=new ByteArrayOutputStream();
      //對象的序列化輸出
      ObjectOutputStream outputStream=new ObjectOutputStream(byOut);//通過字節數組的方式進行傳輸
      outputStream.writeObject(this);  //將當前student對象寫入字節數組中

      //在內存中創建一個字節數組緩衝區,從輸入流讀取的數據保存在該字節數組緩衝區
      ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); //接收字節數組作為參數進行創建
      ObjectInputStream inputStream=new ObjectInputStream(byIn);
      son=(Son) inputStream.readObject(); //從字節數組中讀取
      return  son;
}
複製代碼

使用時候調用我們寫的方法即可,其他不變,實現的效果為:

Son{age=13, name='son1', father=Father{name='bigFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
s1==s2:false
s1.name==s2.name:false

s1.Father==s2.Father:false
s1.name==s2.name:false
Son{age=12, name='son222', father=Father{name='smallFather'}}
Son{age=13, name='son1', father=Father{name='bigFather'}}
複製代碼

寫在最後

原創不易,bigsai請你幫兩件事幫忙一下:

  1. 點贊支持一下, 您的肯定是我在掘金創作的源源動力。

  2. 微信搜索「bigsai」,關注我的公眾號(新人求支持),我會第一時間在公眾號分享知識技術。加我還可拉你進力扣打卡羣一起打卡LeetCode。

感謝你的閲讀、點贊、轉發!