面试题:深拷贝、浅拷贝、引用拷贝的区别

简介: 面试题:深拷贝、浅拷贝、引用拷贝的区别

image.png


引用拷贝

引用拷贝: 引用拷贝不会在堆上创建一个新的对象,只 会在栈上生成一个新的引用地址,最终指向依然是堆上的同一个对象

//实体类
public class Person{
    public String name;//姓名
    public int height;//身高
    public StringBuilder something;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public StringBuilder getSomething() {
        return something;
    }
    public void setSomething(StringBuilder something) {
        this.something = something;
    }
    public Person(String name, int height, StringBuilder something) {
        this.name = name;
        this.height = height;
        this.something = something;
    }
}
//测试类
public class copyTest {
    public static void main(String[] args) {
        Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
        Person p2 = p1;
        System.out.println("对象是否相等:"+ (p1 == p2));
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
        // change
        p1.name="小王";
        p1.height = 200;
        p1.something.append(",适合出去玩");
        System.out.println("...after p1 change....");
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
    }
}

结果:

对象是否相等:true p1 属性值=小张,180,今天天气很好 p2 属性值=小张,180,今天天气很好 ...after p1 change.... p1 属性值=小王,200,今天天气很好,适合出去玩 p2 属性值=小王,200,今天天气很好,适合出去玩

before change:

image.png

after change:

image.png

我们可以看出 由于2个引用p1,p2 都是指向堆中同一个对象,所以2个对象是相等的,修改了对象p1,会影响到对象p2

需要注意的

  1. name属性,虽然她是引用类型,但她同时也是String类型,不可变,对其修改,JVM会默认在堆上创建新的内存空间,再重新赋值
  2. int weight=180;成员变量,存放在堆中,不是所有的基本类型变量 都存放在JVM栈中

注意与这篇文章得区分开来 https://mp.weixin.qq.com/s/6qRspyLAsoBxttGwGtxsAA int num1 = 10;基本类型的局部变量存放在栈中

浅拷贝

浅拷贝 :浅拷贝会在堆上创建一个新的对象,新对象和原对象不等,但是新对象的属性和老对象相同

其中:

  • 如果属性是基本类型(int,double,long,boolean等),拷贝的就是基本类型的值。
  • 如果属性是引用类型(除了基本类型都是引用类型),拷贝的就是引⽤数据类型变量的地址值,⽽对于引⽤类型变量指向的堆中的对象不会拷贝。

如果觉得文章对你有帮助,欢迎关注微信公众号:小牛呼噜噜

如何实现浅拷贝呢?也很简单,就是在需要拷贝的类上实现Cloneable接口并重写其clone()方法

@Override protected Object clone() throws CloneNotSupportedException {   
    return super.clone(); 
}

在使用的时候直接调用类的clone()方法即可

//实体类 继承Cloneable
public class Person implements Cloneable{
    public String name;//姓名
    public int height;//身高
    public StringBuilder something;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getHeight() {
        return height;
    }
    public void setHeight(int height) {
        this.height = height;
    }
    public StringBuilder getSomething() {
        return something;
    }
    public void setSomething(StringBuilder something) {
        this.something = something;
    }
    public Person(String name, int height, StringBuilder something) {
        this.name = name;
        this.height = height;
        this.something = something;
    }
    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
}
//测试类
public class shallowCopyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
        Person p2 = p1.clone();
        System.out.println("对象是否相等:"+ (p1 == p2));
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
        // change
        p1.setName("小王");
        p1.setHeight(200);
        p1.getSomething().append(",适合出去玩");
        System.out.println("...after p1 change....");
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
    }
}

结果:

对象是否相等:false p1 属性值=小张,180,今天天气很好 p2 属性值=小张,180,今天天气很好 ...after p1 change.... p1 属性值=小王,200,今天天气很好,适合出去玩 p2 属性值=小张,180,今天天气很好,适合出去玩

before change:

image.png


after change:

image.png

我们可以看出:

  1. 当我们修改对象p1的weight属性时,由于p2的height属性 是直接复制修改前的p1的height属性,所以还是180。
  2. 当我们修改对象p1的name属性 时,String name指向一个新的内存空间,但对象p2的name还是指向旧的内存空间,所以对象p2的name属性还是"小张"。
  3. 由于对象p1的something属性和对象p2的something属性指向是同一个内存空间,当我们修改对象p1的something属性,会影响到对象p2的something属性,所以对象p2的something属性变为"今天天气很好,适合出去玩"。

深拷贝

深拷贝 :完全拷贝⼀个对象,在堆上创建一个新的对象,拷贝被拷贝对象的成员变量的值,同时堆中的对象也会拷贝。

需要重写clone方法

@Override
    public Person clone() throws CloneNotSupportedException {
        //return (Person) super.clone();
        Person person = (Person) super.clone();
        person.setSomething( new StringBuilder(person.getSomething()));//单独为引用类型clone
        return person;
    }

shallowCopyTest测试类的结果:

对象是否相等:false p1 属性值=小张,180,今天天气很好 p2 属性值=小张,180,今天天气很好 ...after p1 change.... p1 属性值=小王,200,今天天气很好,适合出去玩 p2 属性值=小张,180,今天天气很好

这时候对象p1和对象p2互不干扰了

before change:


image.png

after change:

image.png

但这样也有个小问题,对象每有一个引用类型,我们都得重写其clone方法,这样会非常麻烦,因此我们还可以借助序列化来实现对象的深拷贝

//实体类 继承Cloneable
public class Person implements Serializable{
    public String name;//姓名
    public int height;//身高
    public StringBuilder something;
...//省略 getter setter
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}
//测试类,这边类名笔者就不换了,在之前的基础上改改
public class shallowCopyTest {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person("小张", 180, new StringBuilder("今天天气很好"));
        Person p2 = (Person)p1.deepClone();
        System.out.println("对象是否相等:"+ (p1 == p2));
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
        // change
        p1.setName("小王");
        p1.setHeight(200);
        p1.getSomething().append(",适合出去玩");
        System.out.println("...after p1 change....");
        System.out.println("p1 属性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething());
        System.out.println("p2 属性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething());
    }
}

这样也会得到深拷贝的结果

小结

  1. 引用拷贝: 引用拷贝不会在堆上创建一个新的对象,只 会在栈上生成一个新的引用地址,最终指向依然是堆上的同一个对象
  2. 浅拷贝 :浅拷贝会在堆上创建一个新的对象,新对象和原对象不等,但是新对象的属性和老对象相同

如果觉得文章对你有帮助,欢迎关注微信公众号:小牛呼噜噜

其中:

  • 如果属性是基本类型(int,double,long,boolean等),拷贝的就是基本类型的值。
  • 如果属性是引用类型(除了基本类型都是引用类型),拷贝的就是引⽤数据类型变量的地址值,⽽对于引⽤类型变量指向的堆中的对象不会拷贝。
  1. 深拷贝 :完全拷贝⼀个对象,在堆上创建一个新的对象,拷贝被拷贝对象的成员变量的值,同时堆中的对象也会拷贝。

参考资料:

https://blog.csdn.net/JingLxian/article/details/106337395

https://www.cnblogs.com/hithlb/p/4872373.html

很感谢你能看到最后,如果喜欢的话,欢迎关注点赞收藏转发,谢谢!更多精彩的文章


相关文章
【面试题精讲】深拷贝和浅拷贝区别了解吗?什么是引用拷贝?
【面试题精讲】深拷贝和浅拷贝区别了解吗?什么是引用拷贝?
|
7月前
|
存储 人工智能 前端开发
深拷贝浅拷贝的区别?如何实现一个深拷贝?
深拷贝浅拷贝的区别?如何实现一个深拷贝?
108 0
|
2月前
|
存储
如何理解结构体的浅拷贝与深拷贝
结构体的浅拷贝仅复制对象的引用或基本数据类型值,不创建新对象;深拷贝则会递归地复制所有对象及其引用的对象,形成完全独立的新对象。两者主要区别在于是否共享内部对象。
|
2月前
|
存储 前端开发 JavaScript
浅拷贝和深拷贝的区别?
本文首发于微信公众号“前端徐徐”,介绍了JavaScript中浅拷贝和深拷贝的概念及其实现方法。文章首先解释了数据类型的基础,包括原始值和对象的区别,然后详细介绍了浅拷贝和深拷贝的定义、底层逻辑以及常见的实现方式,如 `Object.assign`、扩展运算符、`JSON.stringify` 和手动实现等。最后,通过对比浅拷贝和深拷贝的区别,帮助读者更好地理解和应用这两种拷贝方式。
67 0
浅拷贝和深拷贝的区别?
|
6月前
|
安全 Java
深拷贝和浅拷贝的区别
深拷贝和浅拷贝的区别
|
7月前
|
Java
对引用拷贝,浅拷贝,深拷贝的理解
对引用拷贝,浅拷贝,深拷贝的理解
41 0
|
7月前
|
存储 Java Apache
【面试问题】深拷贝和浅拷贝的区别?
【1月更文挑战第27天】【面试问题】深拷贝和浅拷贝的区别?
|
存储 JavaScript 前端开发
深拷贝浅拷贝有什么区别?怎么实现深拷贝?
深拷贝浅拷贝有什么区别?怎么实现深拷贝?
99 0
|
JSON 数据格式
深拷贝和浅拷贝、及实现方式
深拷贝和浅拷贝、及实现方式
99 0
|
JavaScript 前端开发 Java
一文搞懂浅拷贝与深拷贝到底有什么区别
一文搞懂浅拷贝与深拷贝到底有什么区别
163 0