深拷贝/浅拷贝

青旅半醒 2022-11-06 05:49 245阅读 0赞

## 一、值传递和引用传递 ##

在谈值传递和引用传递之前先了解下java数据类型有哪些

### Java数据类型 ###

java的数据类型有两大类，基本类型和对象类型。相应的，变量也有两种类型：基本类型和引用类型。

基本类型包括`byte`,`short`,`int`,`long`,`char`,`float`,`double`,`boolean` 这八大基本数据类型，

基本类型的变量保存原始值，即它代表的值就是数值本身，存放在栈内存中的数据段，因为是按值存储，可以直接访问和修改，原始值一般对应在内存上的栈区。

引用类型包括 `类类型`，`接口类型`和`数组`保存的是引用值，引用值指向内存空间的地址。代表了某个对象的引用，而不是对象本身。对象本身存放在这个引用值所表示的地址的位置。被引用的对象对应内存上的堆内存去。

### 变量的基本类型和引用类型的区别 ###

基本数据类型在声明是系统就给它分配空间，无论是否赋值，声明的时候虚拟机就会分配 4字节的内存区域。引用数据类型不同，它声明时只给变量分配了引用空间，而不分配数据空间。

String 类型时声明的时候没有分配数据空间，只有 4byte 的引用大小，在栈区，而在堆内存区域没有任何分配。

`基本类型`的变量是`值传递`；`引用类型`的变量

### 值传递 ###

方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的原始值得一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值得修改，不影响实际参数的值

### 引用传递 ###

一般也称为地址传递。方法调用时，实际参数的引用（地址，而不是参数的值）被传递给方法中相对应的形式参数，函数接收的原始值的内存地址

在方法执行中，形参和实参内容相同，只想同一块内存地址，方法执行中对引用的操作将影响到实际对象。

## 二、什么是深拷贝和浅拷贝 ##

浅拷贝和深拷贝都是对一个已有对象的操作，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函。

在java中，一般使用=好做赋值操作的时候，对于基本数据类型，实际上是拷贝他的值，但是对于对象而言，其实赋值的指示这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的用一个对象。

而浅拷贝和深拷贝就是在这个基础之上做的区分，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有创建一个新的对象，那就是浅拷贝。反之，在对引用数据类型进行拷贝的时候，新创建了一个新的对象，并完全复制了其内的成员变量，那么这就是深拷贝。

**总结来说：**

**1、浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。**

**2、深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。**

## java中的clone方法 ##

clone顾名思义就是复制，在java语言中，clone方法被对象调用，所以会复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新对象。

### 创建对象的方式 ###

在java语言中，有几种方式可以创建对象呢？

1.使用new操作创建一个对象

2.使用clone方法复制一个对象

使用new操作创建对象本意是分配内存。程序只领到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这就叫对象的初始化。对象穿件完毕后，可以把引用发布到外部，在外部就可以使用这个引用操纵这个对象。

clone在第一步和new相似的，都是分配内存的，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后在使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同对象就能被创建，同样吧这个新对象的引用发布到外部。

### 浅拷贝 ###

先来看一个浅拷贝的例子

首先创建一个person类，是想Cloneable接口，并重写clone（）方法

package com.java.test;
    public  class Person implements Cloneable {
        public String name;
        public int age;
        public Man man=new Man();
        public  Object clone(){
            try {
                return   super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return  null;
        }
    
        public static void main(String[] args){
            Person person=new Person();
            person.name="法法";
            person.age=24;
            Person cloneperson=(Person)person.clone();
            System.out.println("person==cloneperson  :"+(person==cloneperson));
            System.out.println("person hash  :"+person.hashCode());
            System.out.println("person hash  :"+cloneperson.hashCode());
            System.out.println("person.man==cloneperson.man  :"+(person.man ==cloneperson.man));
            System.out.println("person.man hash  :"+(person.man.hashCode()));
            System.out.println("cloneperson.man hash  :"+(cloneperson.man.hashCode()));
        }
    }
    class Man implements  Cloneable{
        public String name;
        public int age;
        public  Object clone(){
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }复制代码

输出
    person==cloneperson  :false
    person hash  :2039796785
    person hash  :57283044
    person.man==cloneperson.man  :true
    person.man hash  :1971244528
    cloneperson.man hash  :1971244528
    复制代码

可以看出，使用clone方法，从==和hashCode不同可以看出，clone方法真的穿件了一个新的对象。

![e8bc1ec1e168f2793e348b7ecaf56892.png][]

上面代码中可以看出两个Person对象的man的地址值相同， 说明两个对象的man对象都指向同一个对象， 也就是浅拷贝，。

而如果两个对象的man的地址值不同， 那么就说明指向不同的对象， 也就是在拷贝Person对象的时候， 同时拷贝了man对象， 也就是深拷贝。

### 深拷贝 ###

既然已经了解了对 clone() 方法，只能对当前对象进行浅拷贝，引用类型依然是在传递引用。

那么，如何进行一个深拷贝呢？

比较常用的方案有两种：

1.  序列化（serialization）这个对象，再反序列化回来，就可以得到这个新的对象，无非就是序列化的规则需要我们自己来写。
2.  继续利用 clone() 方法，既然 clone() 方法，是我们来重写的，实际上我们可以对其内的引用类型的变量，再进行一次 clone()。

继续改写上面的 Demo ，让 ChildClass 也实现 Cloneable 接口。

package com.java.test;
    public  class Person implements Cloneable {
        public String name;
        public int age;
        public Man man=new Man();
        public  Object clone(){
            try {
                Person p=(Person) super.clone();
                p.man=(Man)this.man.clone();
                return  p;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return  null;
        }
    
        public static void main(String[] args){
            Person person=new Person();
            person.name="fafa";
            person.age=24;
            Person cloneperson=(Person)person.clone();
            System.out.println("person==cloneperson  :"+(person==cloneperson));
            System.out.println("person hash  :"+person.hashCode());
            System.out.println("person hash  :"+cloneperson.hashCode());
            System.out.println("person.man==cloneperson.man  :"+(person.man ==cloneperson.man));
            System.out.println("person.man hash  :"+(person.man.hashCode()));
            System.out.println("cloneperson.man hash  :"+(cloneperson.man.hashCode()));
        }
    }
    class Man implements  Cloneable{
        public String name;
        public int age;
        public  Object clone(){
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }复制代码

输出

person==cloneperson  :false
    person hash  :1942571857
    person hash  :611315258
    person.man==cloneperson.man  :false
    person.man hash  :813773958
    cloneperson.man hash  :1923048010
    复制代码

可以看到，对 man也进行了一次拷贝，这实则是对 Person进行的浅拷贝，但是对于 Person而言，则是一次深拷贝。

## 总结 ##

实际浅拷贝和深拷贝只是相对的，如果一个对象内部只有基本数据类型，那用 clone() 方法获取到的就是这个对象的深拷贝，而如果其内部还有引用数据类型，那用 clone() 方法就是一次浅拷贝的操作。

clone在平时项目的开发中可能用的不是很频繁，但是区分深拷贝和浅拷贝会让我们对java内存结构和运行方式有更深的了解。深拷贝和彻底深拷贝，在创建不可变对象时，可能对程序有着微妙的影响，可能会决定我们创建的不可变对象是不是真的不可变。

[e8bc1ec1e168f2793e348b7ecaf56892.png]: /images/20221023/315ca584d4064f8a86a869048e8e4043.png