程序员社区

Java中对于深拷贝和浅拷贝的理解

基本类型和引用类型在内存中的保存

Java中数据类型分为两大类:基本类型和对象类型
变量也有两种类型:基本类型和引用类型

基本类型的变量保存原始值,即它代表的值就是数值本身
引用类型的变量保存引用值,"引用值"指向内存空间的地址,代表了某个对象的引用,而不是对象本身,对象本身存放在这个引用值所表示的地址的位置。
基本类型包括:byte,short,int,long,char,float,double,boolean
引用类型包括:类类型,接口类型和数组

引用传递和值传递

值传递:

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

引用传递:

也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,函数接收的是原始值的内存地址;
在方法执行中,形参和实参内容相同,指向同一块内存地址,方法执行中对引用的操作将会影响到实际对象。

直接看下例子

public class Test {
    public static void main(String args[]) {
        int number=123;
        Student stu1 = new Student();
        stu1.setNumber(number);
        Student stu2 =stu1;
        stu2.setNumber(321);
        System.out.println(number);
        System.out.println(stu1 == stu2);
        System.out.println("学生1:" + stu1.getNumber());
        System.out.println("学生2:" + stu2.getNumber());
    }
    static class Student{
        private int number;
        public int getNumber() {
            return number;
        }
        public void setNumber(int number) {
            this.number = number;
        } 
    }
}

测试结果:

Java中对于深拷贝和浅拷贝的理解插图
image.png

main方法中:
number是基本类型,采用值传递,不影响实际参数的值。
Student是类类型,采用引用传递,指向同一块内存地址,对引用的操作将会影响到实际对象。

Student stu2 =stu1;引用传递把stu1stu2指向内存堆中同一个对象。所以当stu2.setNumber(321);时,stu1中的number值也会发生改变

浅拷贝

想要复制一个新对象,也就是开辟一块新的内存地址,那么就要使用到拷贝
1.需要实现Clonenable接口,该接口为标记接口(不含任何方法)
2.覆盖clone()方法,访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象

public class Test {
    public static void main(String args[]) {
        int number=123;
        Student stu1 = new Student();
        stu1.setNumber(number);
        Student stu2 = (Student)stu1.clone();
        stu2.setNumber(321);
        System.out.println(number);
        System.out.println(stu1 == stu2);
        System.out.println("学生1:" + stu1.getNumber());
        System.out.println("学生2:" + stu2.getNumber());
    }
    static class Student implements Cloneable{
        private int number;
        public int getNumber() {
            return number;
        }
        public void setNumber(int number) {
            this.number = number;
        } 
        @Override
        public Object clone() {
            Student stu = null;
            try{
                stu = (Student)super.clone();
            }catch(CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return stu;
        }
    }
}

测试结果:

Java中对于深拷贝和浅拷贝的理解插图1
image.png

main方法中用Student stu2 = (Student)stu1.clone();代替Student stu2 =stu1;,这样才会指向不同的内存地址,stu1 == stu2false说明指向的地址块是不同的,所以对象中number值也是不同的

深拷贝

之前在Student对象中的成员属性都是基本类型的,那如果是引用类型的呢?
先看测试代码

public class Test {
    public static void main(String args[]) {
        int number=123;
        Address addr = new Address();
        addr.setAdd("A");
        Student stu1 = new Student();
        stu1.setNumber(number);
        stu1.setAddr(addr);
        Student stu2 = (Student)stu1.clone();
        stu2.setNumber(321);
        addr.setAdd("B");
        System.out.println(number);
        System.out.println(stu1 == stu2);
        System.out.println(stu1.getAddr()==stu2.getAddr());
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
    }
    static class Student implements Cloneable{
        private int number;
        private Address addr;
        public Address getAddr() {
            return addr;
        }
        public void setAddr(Address addr) {
            this.addr = addr;
        }
        public int getNumber() {
            return number;
        }
        public void setNumber(int number) {
            this.number = number;
        }
        @Override
        public Object clone() {
            Student stu = null;
            try{
                stu = (Student)super.clone();
            }catch(CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return stu;
        }
    }
    static class Address {
        private String add;
        public String getAdd() {
            return add;
        }
        public void setAdd(String add) {
            this.add = add;
        }
    }
}

测试结果:

Java中对于深拷贝和浅拷贝的理解插图2
image.png

可以看出Student对象指向不同的内存地址,但是成员属性Address对象在stu1stu2中都是指向同一内存地址

原因是浅拷贝只是拷贝了addr变量的引用,并没有真正的开辟另一块空间,将值复制后再将引用返回给新对象。
所以,为了达到真正的拷贝对象,而不是纯粹引用复制。我们需要将Address类可复制化,并且修改clone方法,同时Student类也要做下修改

static class Student implements Cloneable{
        private int number;
        private Address addr;
        public Address getAddr() {
            return addr;
        }
        public void setAddr(Address addr) {
            this.addr = addr;
        }
        public int getNumber() {
            return number;
        }
        public void setNumber(int number) {
            this.number = number;
        }
        @Override
        public Object clone() {
            Student stu = null;
            try{
                stu = (Student)super.clone();
            }catch(CloneNotSupportedException e) {
                e.printStackTrace();
            }
            stu.addr = (Address)addr.clone();
            return stu;
        }
    }
    static class Address  implements Cloneable{
        private String add;
        public String getAdd() {
            return add;
        }
        public void setAdd(String add) {
            this.add = add;
        }
        @Override
        public Object clone() {
            Address addr = null;
            try{
                addr = (Address)super.clone();
            }catch(CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return addr;
        }
    }

重点:
1.在Address类中实现Cloneable接口,修改clone方法
2.在Student类的clone方法中加上stu.addr = (Address)addr.clone();实现深拷贝


关于clone()

JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。

new的区别

共同点:都是分配内存,对象都是指向不同的内存地址
不同点:new创建一个对象,clone复制一个对象。new是返回的新对象,而调用clone()方法时,拷贝对象已经包含了一些原来对象的信息,而不是对象的初始信息

复制引用(引用传递)和复制对象

引用都存放在栈区,类对象存放于堆区

Java中对于深拷贝和浅拷贝的理解插图3
image.png

从源码角度看clone()
protected native Object clone() throws CloneNotSupportedException;

Object类的clone()是一个native方法,native方法的效率一般来说都是远高于Java中的非native方法。这也解释了为 什么要用Objectclone()方法而不是先new一个类,然后把原始对象中的信息赋到新对象中,虽然这也实现了clone功能。Java中所有的类是缺省继承Object类的,所以可以直接使用protected属性的方法

为什么要实现Cloneable接口

Cloneable接口是不包含任何方法的,其实这个接口仅仅是一个标志,而且这个标志也仅仅是针对 Object类中clone()方法的,如果实现clone()方法的类没有实现Cloneable接口,并调用了Objectclone()方法(也就是调用了 super.clone()方法),那么Objectclone()方法就会抛出CloneNotSupportedException异常

内存地址

在以上测试中我都是以==去判断两个对象是否指向同一内存地址,如果要查看具体的内存地址值可以这样做
1.可以使用hashCode()方法,在不重写hashCode()的情况下,默认是返回内存地址,不同的hash值代表不同的内存地址
2.使用System.identityHashCode(Object)方法可以返回对象的内存地址,不管该对象的类是否重写了hashCode()方法

源码展示

Object类下
public native int hashCode();
System类下
public static native int identityHashCode(Object x);
拓展

String类重写了hashcode()

private int hash; 
public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

Java中所有类是缺省继承Object类的,所以都有资格去重写hashcode()方法

总结:

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

浅拷贝

对基本数据类型进行值传递,对引用数据类型进行引用传递般的拷贝,此为浅拷贝

深拷贝

对基本数据类型进行值传递,对引用数据类型,会对引用指向的对象进行拷贝,此为深拷贝。也就是在clone()方法对其内的引用类型的变量再进行一次 clone()

区别就在于是否对对象中的引用变量所指向的对象进行拷贝。

赞(0) 打赏
未经允许不得转载:IDEA激活码 » Java中对于深拷贝和浅拷贝的理解

相关推荐

  • 暂无文章

一个分享Java & Python知识的社区