JAVA 深浅拷贝的解析

最新推荐文章于 2024-06-04 14:01:37 发布
最新推荐文章于 2024-06-04 14:01:37 发布
阅读量3.8k 收藏 27
点赞数 10
分类专栏： java8




1.拷贝的引入

（1）引用拷贝

创建一个指向对象的引用变量的拷贝。

例1：

Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;
System.out.println(teacher);
System.out.println(otherteacher);
 
 
  • 1
  • 2
  • 3
  • 4

输出结果：

blog.Teacher@355da254
blog.Teacher@355da254

 
 
  • 1
  • 2
  • 3

结果分析：由输出结果可以看出，它们的地址值是相同的，那么它们肯定是同一个对象。teacher和otherteacher的只是引用而已，他们都指向了一个相同的对象Teacher(“Taylor”,26)。 这就叫做引用拷贝。


例1 图解：
这里写图片描述

（2）对象拷贝

创建对象本身的一个副本。

例2：

Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);
 
 
  • 1
  • 2
  • 3
  • 4

输出结果:

blog.Teacher@355da254
blog.Teacher@4dc63996
 
 
  • 1
  • 2

结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。


例2 图解：
这里写图片描述


注：深拷贝和浅拷贝都是对象拷贝

2.浅拷贝

（1）定义：

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象

（2）浅拷贝实例：

例3：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */
public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student2 student1 = new Student2();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student2 student2 = (Student2) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }

}

class Teacher implements Cloneable
{
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

}

class Student2 implements Cloneable
{
    private String name;
    private int age;
    private Teacher teacher;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

    public Teacher getTeacher()
    {
        return teacher;
    }

    public void setTeacher(Teacher teacher)
    {
        this.teacher = teacher;
    }

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        Object object = super.clone();
        return object;
    }

}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103

输出结果：

拷贝后
Dream
18
Delacey
29
修改老师的信息后-------------
Jam
Jam
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

结果分析： 两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。


例3 图解：
这里写图片描述

3.深拷贝

（1）定义：

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

（2）实现深拷贝（实例1）：

例4：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */

public class DeepCopy {
    public static void main(String[] args) throws Exception
    {
        Teacher2 teacher = new Teacher2();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student3 student1 = new Student3();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}

class Teacher2 implements Cloneable {
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

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

}

class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

    public Teacher2 getTeacher()
    {
        return teacher;
    }

    public void setTeacher(Teacher2 teacher)
    {
        this.teacher = teacher;
    }

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;
    }

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116

输出结果：

拷贝后
Dream
18
Delacey
29
修改老师的信息后-------------
Jam
Delacey
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

结果分析：
两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。


例4 图解1（teacher姓名Delacey更改前）：

这里写图片描述


例4 图解2（teacher姓名Jam更改后）：

这里写图片描述

（3）利用序列化实现深拷贝（实例2）

例5：

package blog;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Created by 白夜行 on 2017/5/13.
 */
public class DeepCopyServiable {
    public static void main(String[] args) throws Exception {
        Teacher3 t = new Teacher3();
        t.setName("Taylor");
        t.setAge(28);

        Student3 s1 = new Student3();
        s1.setAge(20);
        s1.setName("blank space");
        s1.setTeacher(t);

        Student3 s2 = (Student3) s1.deepClone();

        System.out.println("拷贝后:");
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getTeacher().getName());
        System.out.println(s2.getTeacher().getAge());
        System.out.println("---------------------------");

        t.setName("swift");

        System.out.println("修改后：");
        System.out.println(s1.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
    }

}

class Teacher3 implements Serializable
{
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

}

class Student3 implements Serializable
{
    private String name;
    private int age;
    private Teacher3 teacher;

    public String getName()
    {
        return name;
    }

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

    public int getAge()
    {
        return age;
    }

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

    public Teacher3 getTeacher()
    {
        return teacher;
    }

    public void setTeacher(Teacher3 teacher)
    {
        this.teacher = teacher;
    }

    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();
    }

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

输出结果：

拷贝后:
blank space
20
Taylor
28
---------------------------
修改后：
swift
Taylor
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

结果分析：说明用序列化的方式实现了对象的深拷贝





本人才疏学浅，若有错，请指出
谢谢！



        </article>
1232456211
关注
  • 10
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的浅拷贝和深拷贝
qq15035899256的博客
10-07 951
本文是JavaSE的学习，认识什么是拷贝，浅拷贝和深拷贝的区别，实现深拷贝的两种方式。之后的学习内容将持续更新！！！
浅拷贝和深拷贝的区别
热门推荐
m0_73770538的博客
09-16 1万+
1、浅拷贝，指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。 2、深拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。 3、区别：可变对象就不会这样会修改值后另存到一个新的地址上，而是直接再原对象的地址上把值给改变了，这个对象依然执行这个地址 4、本质区别：可变对象修改了值，不会新建一个内存地址的对象，不可变对象如果修改了值，及时复制了一份新的内存地址，原始地址的值不会被
探索Java深拷贝：从基础到高效实现
最新发布
BASK2312的博客
06-04 1042
探索Java深拷贝：从基础到高效实现在Java中，深拷贝是创建对象副本的过程，同时复制其所有嵌套对象和引用类型的字段。正确实现深拷贝对于确保数据一致性和避免副作用至关重要。在本文中，将探讨几种常见的深拷贝方法，分析它们的实现原理及各自的优缺点。1. 使用Cloneable接口和Object.clone()方法实现原理： Java提供了一个原生的克隆机制，通过实现Cloneable接口并重写Object类的clone()方法，可以创建对象的浅拷贝。为了实现深拷贝，需要在clone()
java中的浅拷贝（浅复制）和深拷贝（深复制）
大鹏
05-24 1万+
浅拷贝： 浅拷贝又称为浅复制，浅克隆，浅拷贝是指拷贝时只拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量的值都含有与原来对象相同的值，而所有对其他对象的引用都指向原来的对象，简单地说，浅拷贝只拷贝对象不拷贝引用。 深拷贝： 深拷贝又称为深复制，深克隆，深拷贝不仅拷贝对象本身，而且还拷贝对象包含的引用所指向的对象，拷贝出来的对象的所有变量（不包含那些引用其他对象的变量）的值都含有与原来对象的相同的值，那些引用其他对象的变量将指向新复制...
Java当中的深拷贝和浅拷贝
qq_39939541的博客
07-23 1115
从输出结果可以看出，尽管我们使用BeanUtils进行了拷贝，但person1和person2的属性值仍然是相同的，修改其中一个对象的属性值会同时影响另一个对象的属性值。它会创建一个全新的对象，并将原始对象中的所有属性或元素都复制到新的对象中。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素不会受到任何影响。浅拷贝是一种复制对象到另一个变量的操作，它仅复制对象的地址而非对象本身。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素也会随之改变。
java中深拷贝与浅拷贝详细解释，并结合BeanUtils.copyProperties方法分析
wokeai1999的博客
06-13 2061
浅拷贝和深拷贝是指在 Java 中对象复制时所涉及到的两种不同方式。浅拷贝只是复制了基本类型值和对其他对象的引用，而没有复制引用的对象，即被复制对象和复制对象共用一份引用对象。如果原始对象中某个引用对象发生了变化，那么对应的复制对象也会同步变化。深拷贝则是将对象本身及其引用对象都复制一份，即被复制对象和复制对象各自拥有一份独立的引用对象。即使原始对象中某个引用对象发生变化，复制对象对应的引用对象也不会变化，互相独立。
c python java 复制数组 深浅拷贝
12-22
在不同的语言中，如C、Python和Java，数组复制有深拷贝和浅拷贝两种方式，它们之间的区别在于是否拷贝了底层的数据结构。 在Java中，数组的复制可以通过简单的赋值操作实现，例如`int[] a2 = a1;`。这种方式被称为...
java解析PDF文件
01-24
java解析PDF格式的文件demo。JAVA实现PDF解析，对PDF文件中的文本内容可输出仅供参考学习，不喜勿喷。
java的sql解析器jsqlparser
07-14
Java的SQL解析器JSQLPaser是一个强大的开源库，专门设计用于处理SQL语句的解析工作。这个库允许开发者分析SQL语句的结构，提取出其中的关键元素，如列名、表名、别名以及查询条件，从而在Java应用程序中实现对SQL的...
环保212协议解析java
09-13
2. **XML解析**：Java中可以使用DOM、SAX或StAX API来解析XML文档。DOM一次性加载整个文档，适合小型文件；SAX是事件驱动的，按需读取，适合大文件；StAX允许程序逐个读取事件，提供了更细粒度的控制。 3. **字节流...
HL7 JAVA解析版本
11-22
HL7 2.X解析(JAVA版) Hl7引擎的目标主要是解决将数据按HL7协议的要求标准化，和标准业务的集成和不同系统间标准业务数据的同步。在多年的医院信息化过程中，HL7标准组织和解析最复杂了。本次公开JAVA的
Java 中的浅拷贝和深拷贝
qq_50994235的博客
03-09 1973
Java 中的浅拷贝和深拷贝
深拷贝与浅拷贝
weixin_57959921的博客
03-10 4398
深拷贝与浅拷贝
Java的浅拷贝和深拷贝
qq_60361946的博客
08-07 635
java的浅拷贝和深拷贝学习
java关于深拷贝和浅拷贝的理解
qq_42077317的博客
06-07 687
对于基本数据类型就是直接进行值传递，在内存的另一个空间内存放，修改这个值不会影响到拷贝源的值，对于引用数据类型就是进行的是地址传递，并没有对该对象重新开辟一个内存空间进行存放，所以对于引用数据类型的浅拷贝就相当于两个引用指向了同一个内存地址。说明浅拷贝不会拷贝引用类型指向的对象，只会拷贝引用，指向的仍是同一个地址，所以这两个对象的引用对象是同一个对象，修改就会发生改变，浅拷贝也就是一个封装性的赋值操作。3.如果对象引用任何时候都不会被改变，那么没必要使用深拷贝，只需要使用浅拷贝就行了。
Java深浅拷贝
weixin_73869209的博客
12-25 539
引用拷贝通常指的是浅拷贝，即只复制了对象本身，而没有复制对象内部的引用对象。这意味着原始对象和拷贝对象仍然共享相同的引用对象
java浅拷贝和深拷贝
qq_38976745的博客
11-30 472
这里写自定义目录标题什么是拷贝关于浅拷贝关于深拷贝简单实现深拷贝、浅拷贝实现浅拷贝实现深拷贝拷贝和new创建对象的性能简单对比欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 什么是拷贝 面试中
java深拷贝和浅拷贝
qq_29087399的博客
07-06 237
java深拷贝和浅拷贝
js中浅拷贝和深拷贝的区别
菜鸟要努力鸭的博客
02-27 5139
浅拷贝：有两种方式，一种是把一个对象里面的所有的属性值和方法都复制给另一个对象，另一种是直接把一个对象赋给另一个对象，使得两个都指向同一个对象。 深拷贝：把一个对象的属性和方法一个个找出来，在另一个对象中开辟对应的空间，一个个存储到另一个对象中。 两者就在于，浅拷贝只是简单的复制，对对象里面的对象属性和数组属性只是复制了地址，并没有创建新的相同对象或者数组。而深拷贝是完完全全的复制...
java的深浅拷贝是什么
02-20
Java的深拷贝是指在复制对象的过程中，不仅复制对象本身，而且把对象包含的所有引用也复制一份，即复制对象的所有属性，包括其引用类型的属性所指向的另一个对象。而浅拷贝指的是：仅仅复制对象本身，而不复制对象包含的引用指向的对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值