阅读 2226

深拷贝和浅拷贝

一、值传递和引用传递

在谈值传递和引用传递之前先了解下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方法真的穿件了一个新的对象。



上面代码中可以看出两个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内存结构和运行方式有更深的了解。深拷贝和彻底深拷贝,在创建不可变对象时,可能对程序有着微妙的影响,可能会决定我们创建的不可变对象是不是真的不可变。

关注下面的标签,发现更多相似文章
评论