深浅拷贝详解

最新推荐文章于 2023-06-08 11:45:13 发布
最新推荐文章于 2023-06-08 11:45:13 发布
阅读量563 收藏
点赞数 1
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42617262/article/details/89482043
版权

深浅拷贝

Object类clone()方法

深浅拷贝概念(重要)

深浅拷贝实现方式

我们首先来学习一下Object类中的clone()方法

//我们可以看到，clone()方法为本地方法，且使用该方法可能会抛出CloneNotSupportedException异常
protected native Object clone() throws CloneNotSupportedException;

接下来我们探寻一下CloneNotSupportedException异常出现的原因：

class Teacher{//自定义teacher类，其中包含两个属性及构造方法 getter setter方法
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}
//自定义Student类，与Teacher类不同的是Student类中除了两个普通属性外还包括Teacher属性
class Student{
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(String name, Integer age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }
    //我们知道clone()方法是Object类中方法，所有类均默认继承Object类，Student类中clone()方法实际上是覆写Object类中clone()方法，因我们希望拷贝Student类故返回类型为Student
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();//直接调用Object类中clone()方法，但注意向下转型强转
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Test{
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher=new Teacher("小芳","Java teacher");
        Student student=new Student("小花",20,teacher);
        Student studentClone=student.clone();
        //获得拷贝Student中属性，查看是否拷贝成功
        System.out.println(studentClone.getName());
        System.out.println(studentClone.getAge());
        System.out.println(studentClone.getTeacher());
        System.out.println(teacher==studentClone.getTeacher());//判断拷贝对象中teacher对象是否与之前地址相同
    }
}
//Exception in thread "main" java.lang.CloneNotSupportedException: Student
	//at java.lang.Object.clone(Native Method)
	//at Student.clone(Test.java:45)
	//at Test.main(Test.java:75)

通过以上代码我们可以看到，在程序运行阶段抛出异常，实际上通过查看源码可知存在Cloneable接口，该接口内无任何方法，但并不是所有类均可进行拷贝，若想拷贝则必须实现Clonable接口(标志接口)否则就会抛出CloneNotSupportedException异常。

在这里插入图片描述

//Cloneable源码
 * @see     java.lang.CloneNotSupportedException
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */
public interface Cloneable {
}

故上文中我们要对Student类进行拷贝，Student类就应该实现Cloneable接口。对上文代码进行修改：

class Teacher{
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}
class Student implements Cloneable{
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(String name, Integer age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Test{
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher=new Teacher("小芳","Java teacher");
        Student student=new Student("小花",20,teacher);
        Student studentClone=student.clone();
        System.out.println(studentClone.getName());
        System.out.println(studentClone.getAge());
        System.out.println(studentClone.getTeacher());
        System.out.println(teacher==studentClone.getTeacher());
    }
}
//小花
//20
//Teacher{name='小芳', job='Java teacher'}
//true
接下来简单学习一下深浅拷贝的概念(熟悉)
浅拷贝–对象值拷贝(基本类型内容拷贝，引用类型地址拷贝(即栈内存拷贝对象指向原对象))

对于浅拷贝而言，拷贝出来的对象仍然保留原对象的所有引用。

浅拷贝问题：只要任意一个拷贝对象(或原对象)中的引用发生改变，所有对象均会收到影响。
深拷贝：拷贝出来的对象产生了所有引用的新对象

深拷贝特点：修改任意一个对象，不会对其他对象产生影响。

深浅拷贝的实现方式：
浅拷贝

如上文代码实际上就为浅拷贝，因拷贝的新对象中teacher类与旧对象地址相同。这就说明无论拷贝多少，其地址均指向同一块内存。

//改变teacher对象地址
class Teacher{
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}
class Student implements Cloneable{
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(String name, Integer age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Test{
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher=new Teacher("小芳","Java teacher");
        Teacher teacher1=new Teacher("小红","Python teacher");
        Student student=new Student("小花",20,teacher);
        teacher=teacher1;//引用传递
        Student studentClone=student.clone();
        System.out.println(studentClone.getName());
        System.out.println(studentClone.getAge());
        System.out.println(studentClone.getTeacher());
        System.out.println(teacher==studentClone.getTeacher());
    }
}
//小花
//20
//Teacher{name='小芳', job='Java teacher'}
//false
深拷贝

(1)利用递归思想实现深拷贝。也就是说不论是要拷贝的类还是作为该类属性的第三方自定义类均需实现Cloneable接口，类内部覆写Object类的clone()方法。

(2)序列化实现深拷贝(常用)–不再实现Cloneable接口，但需实现Serializable(序列化标志接口)，只需在要拷贝的类中定义方法进行数据拷贝即可(注意此时该方法名称不可为clone，因此时并不是覆写Object类中clone()方法而是通过内存进行对象拷贝)
//递归思想实现深拷贝
import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

import java.io.*;
class Person implements Cloneable{
    private String name;

    public Person(String name) {
        this.name = name;
    }
    public Person clone(){
        Person person=null;
        try {
            person=(Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Teacher implements Cloneable{
    private String name;
    private String job;
    private Person person;

    public Teacher(String name, String job, Person person) {
        this.name = name;
        this.job = job;
        this.person = person;
    }

    public Teacher clone(){
        Teacher teacher=null;
        try {
            teacher= (Teacher) super.clone();
            teacher.person=this.person.clone();//调用Person类的clone()方法
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return teacher;
    }
    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", person=" + person +
                '}';
    }
}
class Student implements Cloneable {
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(String name, Integer age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }
    public Student clone(){
        Student student=null;
        try {
            student= (Student) super.clone();
            student.teacher=this.teacher.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return student;
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Test{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person person=new Person("花花");
        Teacher teacher=new Teacher("小芳","Java teacher",person);
        Student student=new Student("小花",20,teacher);
        Student studentClone=student.clone();
        System.out.println(studentClone.getName());
        System.out.println(studentClone.getAge());
        System.out.println(studentClone.getTeacher());
        System.out.println(teacher==studentClone.getTeacher());
    }
}
//小花
//20
//Teacher{name='小芳', job='Java teacher', person=Person{name='花花'}}
//false

//序列化实现深拷贝
import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

import java.io.*;

class Teacher implements Serializable{
    private String name;
    private String job;

    public Teacher(String name, String job) {
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}
class Student implements Serializable {
    private String name;
    private Integer age;
    private Teacher teacher;

    public Student(String name, Integer age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }
    public Student cloneObject() throws IOException, ClassNotFoundException {
        //利用内存进行拷贝操作
        ByteOutputStream bos=new ByteOutputStream();//获得内存输出流
        ObjectOutputStream oos=new ObjectOutputStream(bos);//序列化
        oos.writeObject(this);//向内存中写入数据
        ByteArrayInputStream bis=new ByteArrayInputStream(bos.getBytes());//获得内存输入流
        ObjectInputStream ois=new ObjectInputStream(bis);//反序列化
        return (Student) ois.readObject();//从内存中读取数据
    }
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Test{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Teacher teacher=new Teacher("小芳","Java teacher");
        Student student=new Student("小花",20,teacher);
        Student studentClone=student.cloneObject();
        System.out.println(studentClone.getName());
        System.out.println(studentClone.getAge());
        System.out.println(studentClone.getTeacher());
        System.out.println(teacher==studentClone.getTeacher());
    }
}
//小花
//20
//Teacher{name='小芳', job='Java teacher'}
//false
猪饲夫妇、
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
理解深拷贝和浅拷贝
m0_65558076的博客
03-28 2万+
目录 一、深浅拷贝是什么？ 二、深浅拷贝基础（数据类型） 1.基础数据类型（值传递） 2.复杂数据类型（地址传递） 三、深浅拷贝怎样操作（代码示例） 1.浅拷贝： 1）通过Object.assign for in 进行浅拷贝 2.深拷贝： 1）深拷贝最简单的实现是: JSON.parse(JSON.stringify(obj)) 2）实现一个 deepClone 函数 （深拷贝，完美） 3）递归拷贝 一、深浅拷贝是什么？ 首先我们要明白一点，js中数据类...
javascript之深浅拷贝
编程界明世隐的博客
12-05 3015
浅拷贝： 浅拷贝只拷贝基本类型的数据，而符合类型的数据只复制指向其的指针，而不复制对象本身，新旧对象还是共享同一块内存。 深拷贝： 深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。 浅拷贝的实例: /** * 浅拷贝 * * @param {Object} target 目标对象 * @param {Object} source 源对象 * @return {Object} 返回目标对象 */ function extend(target, s
实现深浅拷贝的方法有哪些？
weixin_43912756的博客
09-15 3207
参考：js浅拷贝及深拷贝的几种方法 1、浅拷贝 (1) Object.assign() 参考：Object.assign()用法讲解 var obj1 = {a: 1, b: 2}; var obj2 = Object.assign({}, obj1); (2) 解构赋值 var obj1 = {a: 1, b: 2}; var obj2 = {...obj1}; 浅拷贝实现原理： function shallowCopy(obj) { var target = {}; for (let i i
详解js中的浅拷贝与深拷贝
DZQ1223的博客
05-30 3653
栈(stack):由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；堆(heap)：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表浅拷贝就是只拷贝基础数据类型的数据，并且数据只有单一的一层，而深拷贝用于拷贝具有复杂的数据类型的数据。
【深拷贝和浅拷贝】
最新发布
weixin_43489232的博客
06-08 982
浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。目前常用的属性拷贝工具，包括Apache的BeanUtils、Spring的BeanUtils、Cglib的BeanCopier、mapstruct都是浅拷贝。浅拷贝会创建一个新对象，新对象和原对象本身没有任何关系，新对象和原对象不等，但是新对象的属性和老对象相同。具体可以看如下区别：如果属性是基本类型(int,double,long,boolean等)，拷贝的就是基本类型的值；
详解python深浅拷贝区别
09-19
在本篇文章里小编给大家整理了关于python深浅拷贝区别的相关知识点总结，有兴趣的朋友们可以参考下。
详解iOS的深浅拷贝
01-20
iOS中的深浅拷贝是Objective-C编程中一个重要的概念，主要涉及到对象的复制行为。对象拷贝分为浅拷贝（shallow copy）、深拷贝（deep copy）以及完全复制（real-deep copy）。理解这些概念对于正确管理和维护数据的...
javascript简单实现深浅拷贝过程详解
10-16
主要介绍了javascript简单实现深浅拷贝过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
深拷贝与浅拷贝
weixin_57959921的博客
03-10 4296
深拷贝与浅拷贝
js实现深浅拷贝的几种方法，实例讲解
qzo_smile的博客
04-27 5380
为什么会有深浅拷贝？ js有基本类型和引用类型 基本类型 string number boolean undefined null symbol 引用类型 object function array 涉及到栈内存和堆内存 基本类型创建的变量和值都保存在栈内存中，name 和 val，当复制时，栈内存会新开辟一个内存，它们 之间就不会相互影响。 引用类型的变量在栈内存中（name）， val指向的是一个堆地址，值保存在堆内存中，当复制时，在栈内存创建一个新的变量，但是val依然指向那个堆地址，值发生改
【基础知识】深拷贝和浅拷贝
m0_56573171的博客
04-11 1182
在实现类的拷贝构造函数和赋值操作符时，根据具体情况选择深拷贝还是浅拷贝，以确保对象拷贝行为的正确性和安全性。深拷贝是一种对象拷贝方式，它会创建一个新的对象，并将原始对象中的所有数据成员复制到新的对象中，包括多态分配内存。浅拷贝是一种对象拷贝方式，它只是简单地将原始对象的内存内容按位复制到新的对象中，包括指针的复制，而不会创建新的内存空间。浅拷贝和深拷贝的区别在于，两个指针变量指向的是同一块空间还是指向不同的空间，如果没有创建内存的操作就是浅拷贝，否则就是深拷贝；3. 深拷贝和浅拷贝的区别。
深拷贝与浅拷贝（方法剖析）
Alone_Endeavor的博客
01-07 213
深拷贝、浅拷贝
如何实现一个深浅拷贝
从人到猿
10-19 3797
把深浅拷贝单独作为一讲来专门讲解，是因为在 JavaScript 的编程中经常需要对数据进行复制，什么时候用深拷贝、什么时候用浅拷贝，是开发过程中需要思考的；同时深浅拷贝也是前端面试中比较高频的题目。 因此，深入学习这部分知识有助于提高手写 JS 的能力，以及对一些边界特殊情况的深入思考能力，这一讲会结合最基础但是又容易写不好的的题目来帮助提升。
深浅拷贝的几种方法
qq_41893686的博客
03-04 582
深拷贝 方法一：递归 let user={ name:"咳咳", person:{ age:12 }, data:[] } function copy(object) { let obj = object instanceof Array ? [] : {}; for (const [k, v] of Object.entries(object)) { d
通俗易懂深浅拷贝的理解
程序员小曲的博客
03-13 1714
要理解深浅拷贝，就要先知道js的数据类型有哪些。分为基本数据类型(string,number,undefind,null,symbol,boolean)和引用数据类型(obj,array,function) 基本数据类型以值得形式存储在栈中，操作的变量是值，而引用类型的值是存储在堆中，以地址来操作变量， 也就是说，基本类型拷贝之后是重新在栈中开辟一个空间，两者不干扰，所以基本类型不分深浅拷贝。但是...
什么是深拷贝、什么是浅拷贝？两者的区别?
weixin_62930485的博客
03-12 4465
浅拷贝的概念及代码、深拷贝的概念及代码、浅拷贝和深拷贝的区别
我自己常用的几个JS深浅拷贝的方法
扫地僧
04-14 356
案例代码 let obj = [ { name: 'robin', age: 24, num: [ { sleep: '8', eat: 'chicked', happy: [1,2,3] } ] } ] 深拷贝 JSON let newObj = JSON.parse(JSON.stringify(obj)) jQue...
深浅拷贝的原理与区别
HiMark
08-07 1352
String类：标准库类型string类表示可变长的字符序列，定义在std中，专门用来管理字符串 一，浅拷贝 浅拷贝，是指原对象与拷贝对象公用一份实体，仅仅是对象名字不同而已，其中任何一个对象改变都会导致其他的对象也跟着它变。如下面这段代码： #include<iostream> #include<cstr
面试.docx
10-26
在JavaScript中，数据类型分为基本数据类型和引用数据类型。 基本数据类型包括：Null，undefined，Boolean，...深拷贝和浅拷贝是针对引用数据类型来说的，深拷贝复制了对象的所有属性和方法，而浅拷贝只拷贝一层。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值