2. 程式人生 > >初始JAVA中淺拷貝和深拷貝

初始JAVA中淺拷貝和深拷貝

阿新 • • 發佈：2018-09-22
exc 深度復制 tst 圖片 們的 over 地方 per 發生

1. 簡單變量的復制

public static void main(String[] args) {
        int a = 5;
        int b = a;
        System.out.println(a);
        System.out.println(b);
    }

八種基本數據類型的（int,boolean,char,byte,short,float,double.long)都適用於這種情況。

2. 對象的復制

對象的復制並沒有基本類型變量的復制這麽簡單，下面看一個例子

2.1 準備一個Student類

package
 
 com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:20
 */
public class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.2 測試Object的測試

package com.jepson.java;


 
/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("jepson");
        Student stu2 = stu1;
        System.out.println("student1:"+stu1.getName());
        System.out.println(
 
"student2:"+stu2.getName());
    }
}

2.3 運行結果

student1:jepson
student2:jepson

2.4 總結

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

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

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

難道真的是這樣嗎？

2.5 舉一反三

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

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("jepson");
        Student stu2 = stu1;
        stu2.setName("tom");
        System.out.println("student1:"+stu1.getName());
        System.out.println("student2:"+stu2.getName());
    }
}

打印結果

student1:tom
student2:tom

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

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

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

技術分享圖片

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

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

該方法的簽名是：

protected native Object clone() throws CloneNotSupportedException;

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

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

3 對象的淺拷貝（淺復制）

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

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

3.1 修改Student類

1.實現Cloneable接口

2.重寫clone方法

3.訪問修飾符改為public

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:20
 */
public class Student implements Cloneable{

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3.2 修改測試類

1.調用clone方法。

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("jepson");
        Student stu2 = (Student)stu1.clone();
        stu2.setName("淺拷貝-tom");
        System.out.println("student1:"+stu1.getName());
        System.out.println("student2:"+stu2.getName());
    }
}

打印結果

技術分享圖片

如果你還不相信這兩個對象不是同一個對象，那麽可以測試一下

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("jepson");
        Student stu2 = (Student)stu1.clone();
        stu2.setName("淺拷貝-tom");
        System.out.println("student1:"+stu1.getName());
        System.out.println("student2:"+stu2.getName());
        System.out.println(stu1==stu2);
    }
}

打印結果

技術分享圖片

4 對象的深拷貝（深復制）

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

Address類如下：

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:57
 */
public class Address {
    private  String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address=‘" + address + ‘\‘‘ +
                ‘}‘;
    }
}

Student類如下：

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:20
 */
public class Student implements Cloneable{

    private String name;

    private  Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }

}

測試類

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Address address = new Address();
        address.setAddress("成都市");

        Student stu1 = new Student();
        stu1.setName("jepson");
        stu1.setAddress(address);


        Student stu2 = (Student)stu1.clone();


        stu2.setName("深拷貝-tom");
        System.out.println("student1:"+stu1.getName()+"::::"+stu1.getAddress());
        System.out.println("student2:"+stu2.getName()+"::::"+stu2.getAddress());
        System.out.println(stu1==stu2);
    }
}

打印結果

技術分享圖片

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

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

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Address address = new Address();
        address.setAddress("成都市");
        Student stu1 = new Student();
        stu1.setName("jepson");
        stu1.setAddress(address);


        Student stu2 = (Student)stu1.clone();

        stu2.setName("深拷貝-tom");
        System.out.println("student1:"+stu1.getName()+"::::"+stu1.getAddress());
        System.out.println("student2:"+stu2.getName()+"::::"+stu2.getAddress());

        address.setAddress("重慶區");
        stu2.setName("深拷貝-tom");
        System.out.println("student1:"+stu1.getName()+"::::"+stu1.getAddress());
        System.out.println("student2:"+stu2.getName()+"::::"+stu2.getAddress());

        System.out.println(stu1==stu2);
    }
}

打印結果

技術分享圖片

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

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

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

1.修改Address類

1.實現Cloneable接口

2.重寫clone方法

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:57
 */
public class Address implements Cloneable{
    private  String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address=‘" + address + ‘\‘‘ +
                ‘}‘;
    }

    @Override
    protected Object clone() {
        Address addr = null;
        try{
            addr = (Address)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return addr;
    }
}

2. 修改Student類

clone方法中加入深度復制

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:20
 */
public class Student implements Cloneable{

    private String name;

    private  Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();  // 淺復制
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        stu.address = (Address)address.clone();   //深度復制
        return stu;
    }

}

3. 測試類

package com.jepson.java;

/**
 * @author jepson
 * @create 2018-09-21 23:21
 */
public class TestObjectCopy {
    public static void main(String[] args) {
        Address address = new Address();
        address.setAddress("成都市");
        Student stu1 = new Student();
        stu1.setName("jepson");
        stu1.setAddress(address);


        Student stu2 = (Student)stu1.clone();

        stu2.setName("深拷貝-tom");
        System.out.println("student1:"+stu1.getName()+"::::"+stu1.getAddress());
        System.out.println("student2:"+stu2.getName()+"::::"+stu2.getAddress());

        address.setAddress("重慶區");
        stu2.setName("深拷貝-tom");
        System.out.println("student1:"+stu1.getName()+"::::"+stu1.getAddress());
        System.out.println("student2:"+stu2.getName()+"::::"+stu2.getAddress());

        System.out.println(stu1==stu2);
    }
}

技術分享圖片

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

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

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

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

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

初始JAVA中淺拷貝和深拷貝

相關推薦

初始JAVA中淺拷貝和深拷貝

exc 深度復制 tst 圖片 們的 over 地方 per 發生 1. 簡單變量的復制 public static void main(String[] args) { int a = 5; int b = a;

淺拷貝和深拷貝(談談java中的clone)

clone顧名思義就是複製， 在Java語言中， clone方法被物件呼叫，所以會複製物件。所謂的複製物件，首先要分配一個和源物件同樣大小的空間，在這個空間中建立一個新的物件。那麼在java語言中，有幾種方式可以建立物件呢？ 1. 使用new操作

python中的淺拷貝和深拷貝

div blog deep imp class pri cnblogs 字符串 style 1.淺拷貝 copy.copy() 淺拷貝是拷貝只拷貝最外一層（這裏所說的拷貝是重新生成一個內存地址，也就是只有最外層的地址是重新生成） import copy li=[23,45

java淺拷貝和深拷貝

一起 head 有著 cloneabl 獨立 head對象 影響 如果 覆蓋 轉：http://blog.csdn.net/u014727260/article/details/55003402 實現clone的2點： 1，clone方法是Object類的一個方法

JavaScript中的淺拷貝和深拷貝

ons == 進行 新建 手動 一個 var javascrip 空間 淺拷貝：拷貝引用。 拷貝後的新對象和源對象都是指向同一個引用地址，因此彼此之間操作互相影響。 let a = {num:1}; let b = a; console.log(a===b); //true

Python 中的淺拷貝和深拷貝

ont () ebe ans 深拷貝 函數 port epc com 1. 列表和字典，直接賦值，都是淺拷貝，即賦值雙方指向同一地址，因為 Python 對可變對象按引用傳遞。 >>> a = [1, 2, 3] >>> b

淺談java淺拷貝和深拷貝

原來 變量 基本數據 的區別 引用數據類型 復制 值傳遞 ec2 深拷貝和淺拷貝 前言:深拷貝和淺拷貝的區別是什麽？ 淺拷貝：被復制的對象的所有變量都含有原來對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之， 淺拷貝僅僅復制所考慮的對象，而不復制它所引用的對

java淺拷貝和深拷貝(基礎也是很重要的)

inf n) vat 實現 技術 變量 hub -h 接口 對象的copy你興許只是懵懂，或者是並沒在意，來了解下吧。 對於的github基礎代碼https://github.com/chywx/JavaSE 最近學習c++，跟java很是相像，在慕課網學習c++也算是

Java: 淺拷貝和深拷貝的理解和實現方式

Java中的物件拷貝(Object Copy)指的是將一個物件的所有屬性（成員變數）拷貝到另一個有著相同類型別的物件中去。舉例說明：比如，物件A和物件B都屬於類S，具有屬性a和b。那麼對物件A進行拷貝操作賦值給物件B就是：B.a=A.a;  B.b=A.b; 在程式中拷貝物件是很常見的

對java的淺拷貝和深拷貝的理解

參考網址：http://www.cnblogs.com/chenssy/p/3308489.html 、https://blog.csdn.net/chenssy/article/details/12952063 淺拷貝：使用一個已知例項對新建立例項的成員變數逐個賦值，這個方式被稱為淺

C語言中的淺拷貝和深拷貝

淺拷貝 首先看下面這段程式碼： # include<assert.h> # include<string.h> #include <stdlib.h> typedef struct Node//定義了一個結構體 { int size; char *da

JS中的淺拷貝和深拷貝。

拷貝 結果 如果 string typeof aso clone return isarray //淺拷貝 var o1 = { a: 10, b: 20, c: 30 }; var o2 = o1; o2.a = 100; console.log(o1);

JavaScript中淺拷貝和深拷貝，棧堆詳解

版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/weixin_40983119/article/details/82995151 簡單來說，JavaScript中單個等於號的賦值就是拷貝，但是呢這個這個賦值可以分為兩種，一種是賦的是資料，一種是賦

理解javascript中淺拷貝和深拷貝

首先，我們要知道javascript的資料型別。 javascript有兩種資料型別，基礎資料型別和引用資料型別。 基礎資料型別：儲存在棧記憶體中的簡單資料段，有undefined，boolean，number，string，null。 引用資料型別：Array，物件，Function儲

java物件的淺拷貝和深拷貝

淺拷貝 java的資料型別有基本資料型別（如：int、long等）和引用資料型別。例如：物件1中有屬性a（基本資料型別）和屬性b（引用資料型別），在進行淺拷貝到物件2時，屬性a複製屬性的值給物件2，這樣物件1和物件2修改屬性a時不會相互影響。屬性b則是複製一份引用（即記憶體地址）給物件2，這樣物件1修改屬

java淺拷貝和深拷貝的區別

淺拷貝是指：只複製一個物件，物件內部存在的指向其他物件陣列或者引用則不復制。 深拷貝是指：不僅複製當前的物件，如果物件中還存在引用，則將引用的物件一起復制。 java中使用到的clone方法是淺拷貝，下面是簡單演示： 首先定義一個簡單類A，申明一個屬性aa = 1；

opencv 中的淺拷貝和深拷貝

1）淺拷貝：   Mat B;   B = image  // 第一種方式   Mat C(image); // 第二種方式 這兩種方式稱為淺copy，是由於它們有不同的矩陣頭，但是它們共享記憶體空間，即指向一個矩陣。當影象矩陣發生變化時，兩者相關聯，都會變化。 （

Python3中的淺拷貝和深拷貝入門理解

1，變數：是一個系統表的元素，擁有指向物件的連線空間  2，物件：被分配的一塊記憶體，儲存其所代表的值  3，引用：是自動形成的從變數到物件的指標  淺拷貝：複製了父物件，沒有拷貝子物件 a

java 淺拷貝和深拷貝 物件克隆clone

轉載：https://www.cnblogs.com/xuanxufeng/p/6558330.html#top class Professor0 implements Cloneable { String name; int age; Professor0(String

Python 中的淺拷貝和深拷貝詳解

Python 中的淺拷貝與深拷貝詳解 轉載請註明出處：https://blog.csdn.net/jpch89/article/details/85028862 文章目錄 Python 中的淺拷貝與深拷貝詳解 1. 淺拷貝