Java拷贝（克隆）原理

已于 2022-02-24 15:59:35 修改
阅读量1.1k 收藏 5
点赞数 1
文章标签： java 开发语言 后端
于 2022-01-09 23:56:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42706375/article/details/122400739
版权

文章目录

1. 基本类型和引用类型的区别

Java中的数据类型分为两大类，基本数据类型和引用类型

1.1 基本数据类型

基本数据类型有八种类型，大致按照如下分类
①整数类型：long、int、short、byte
②浮点类型：float、double
③字符类型：char
④布尔类型：boolean

数据类型位数范围默认值
byte（字节型）8-128（-27）~127（27 - 1）0
short（短整型）16-32768（-215）~32767（215 - 1）0
int（整型）32-2147483648（-231）~2147483647（231 - 1）0
long（长整型）64-9223372036854775808（-263）~9223372036854775807（263 - 1）0L
float（单精度）32-3.4E38~3.4E380.0f
double（双精度）64-1.7E308~1.7E3080.0d
char（字符）16\u0000（十进制等效值为 0）~\uffff（即为 65535）‘\u0000’
boolean（布尔）1true或falsefalse

注：1字节等于8位，即1byte（字节）= 8bit（位）

1.2 引用类型

  • 变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 所有引用类型的默认值都是null。
  • 一个引用变量可以用来引用任何与之兼容的类型。
  • 例子：String str = new String(“hello world”)。

注：在Java中，基本类型都有对应的封装类：

数据类型封装类
byteByte
shortShort
longLong
intInteger
floatFloat
doubleDouble
charCharacter
booleanBoolean

这样用的原因跟泛型必须包容的是引用类型有关，然后咱们经常用的集合List、Set有些使用到了泛型，还有一个很重要的点就是像int默认值是0，Integer默认值是null，咱们可以通过这一点去判断是否有输入数据，因为在数据库里null是不会显示值的，当然你也可以做多一步逻辑判断。

1.3 区别

先看一段实例代码（建议用idea最后一行打断点看地址）:

public class SpaceTest {
    public static void main(String[] args) {
        int a = 1;
        Integer b = 3;
        Integer[] integers = new Integer[3];
        int[] arr = new int[3];
        arr[0] = a;
        integers[0] = b;
    }
}

可以看到这里我定义了两个基本数据类型int->a，对应的（引用类型）封装类Integer->b，一个int数组arr，一个Integer数组integers，通过debug打断点可以看到具体的地址是什么。
debug结果

根据上图咱们看到

  • a是没有地址的只有数值，然后对象b、数组integers、arr是有地址分配的
  • 数组arr存放的是基本数据类型所以里面的值也是没有分配地址的，并且没赋值的下标是有初始化值0的
  • 数组integers里面存放的也是引用类型，所以下标0赋值b是有地址的，并且跟b地址一致，其余没赋值的下标均为null

main()方法体内的局部变量是存放在栈里，引用类型是存放在堆里，咱们画图分析一下：

在这里插入图片描述

2. 序列化原理

序列化相关可以看我另一篇：Java序列化和反序列化

3. 浅拷贝的原理和实现

为了方便理解，咱们这里先创建一个Student类：

public class Student {
    int id;
    String name;
    int age;
    Student(int id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
	public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setId(int id) {
        this.id = id;
    }

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

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

3.1 浅拷贝的实现方式

  • 实现Cloneable接口，并重写clone()方法

这里对Student类进行改造，实现Cloneable接口并重写clone()方法

public class Student implements Cloneable{
    int id;
    String name;
    int age;
    Student(int id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setId(int id) {
        this.id = id;
    }

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

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

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

main方法

public class SpaceTest {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student stu1 = new Student(1,"张三",18);
        Student stu2 = (Student) stu1.clone();
        System.out.println(stu1);
        System.out.println(stu2);
    }
}

运行结果

clone.test.Student@29453f44
clone.test.Student@5cad8086

可以看出两个对象的地址不同，这里就实现了对象的拷贝了。

3.2 原理

浅拷贝是对象拷贝，网上把基本类型和对象的直接赋值也称为浅拷贝

Student a = new Student(1,"张三",18);
Student b = a;

我认为拷贝你起码对象是创建了一个新的出来，而不是两个对象都指向同一个地址（本质上还是一个对象），浅拷贝的原理其实就是new一个新对象b（开辟新的内存空间），并把已存在的相同引用对象a的成员变量值赋予b，例如3.1

Student a = new Student(1,"张三",18);
Student b = (Student) a.clone();

4. 深拷贝的原理和实现

浅拷贝和深拷贝都是对象拷贝，但是浅拷贝只能拷贝外层的成员变量，如果你的成员变量有一个引用类型你修改这个引用对象会发现浅拷贝是两个对象一起变相同的值

public class SpaceTest {
    public static void main(String[] args) throws CloneNotSupportedException{
        Teacher tea1 = new Teacher(10,"赵老师",25);
        Student stu1 = new Student(1,"张三",18,tea1);
        System.out.println(stu1.toString());
        Student stu2 = (Student) stu1.clone();
        stu2.setName("李四");
        stu2.setAge(20);
        stu2.getTeacher().setName("李老师");
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

运行结果，会发现这里你改变stu2对象的Teacher，stu1也会随着更改。

Student{id=1, name='张三', age=18, teacher=Student{id=10, name='赵老师', age=25}}
Student{id=1, name='张三', age=18, teacher=Student{id=10, name='李老师', age=25}}
Student{id=1, name='李四', age=20, teacher=Student{id=10, name='李老师', age=25}}

深拷贝才能真正实现完全拷贝，先新增一个Teacher类。

public class Teacher {
    int id;
    String name;
    int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

改造一下Student类，新增引用类型Teacher的成员变量和getter、setter方法、重载构造器

public class Student implements Cloneable{
    int id;
    String name;
    int age;
    Teacher teacher;
    Student(int id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    Student(int id,String name,int age,Teacher teacher){
        this.id = id;
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setId(int id) {
        this.id = id;
    }

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

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

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    
	@Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", teacher=" + teacher +
                '}';
    }
	
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

4.1 深拷贝的两种实现方式

  1. 创建新的引用类型对象（成员变量）

这里直接new一个新的Teacher对象tea2，再给stu2对象setTeacher(tea2)

public class SpaceTest {
    public static void main(String[] args) throws CloneNotSupportedException{
        Teacher tea1 = new Teacher(10,"赵老师",25);
        Teacher tea2 = new Teacher(20,"李老师",30);
        Student stu1 = new Student(1,"张三",18,tea1);
        System.out.println(stu1.toString());
        Student stu2 = (Student) stu1.clone();
        stu2.setName("李四");
        stu2.setAge(20);
        stu2.setTeacher(tea2);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

运行结果

Student{id=1, name='张三', age=18, teacher=Student{id=10, name='赵老师', age=25}}
Student{id=1, name='张三', age=18, teacher=Student{id=10, name='赵老师', age=25}}
Student{id=1, name='李四', age=20, teacher=Student{id=20, name='李老师', age=30}}

这里就真正实现了深拷贝，stu1对象并不会因为stu2的setTeacher(tea2)而改变自己的teacher引用，问题是你不可能因为引用类里面有几个引用类型的成员变量就去new多少个吧，这样太麻烦，咱们可以看2的实现方式。

  1. 直接调用工具类Hutool提供的方法（序列化和反序列化）

用过maven的可以直接pom文件编写依赖，导入hutool工具

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.1</version>
        </dependency>

Student类和Teacher都实现Serializable接口

public class Student implements Cloneable, Serializable
public class Teacher implements Serializable

改造main方法的拷贝方式

public class SpaceTest {
    public static void main(String[] args) throws CloneNotSupportedException{
        Teacher tea1 = new Teacher(10,"赵老师",25);
        Student stu1 = new Student(1,"张三",18,tea1);
        System.out.println(stu1.toString());
        Student stu2 = ObjectUtil.cloneByStream(stu1);
        stu2.setName("李四");
        stu2.setAge(20);
        stu2.getTeacher().setName("马老师");
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

运行结果

Student{id=1, name='张三', age=18, teacher=Student{id=10, name='赵老师', age=25}}
Student{id=1, name='张三', age=18, teacher=Student{id=10, name='赵老师', age=25}}
Student{id=1, name='李四', age=20, teacher=Student{id=10, name='马老师', age=25}}

可以看到利用ObjectUtil.cloneByStream方法也能实现深拷贝，原理看4.2

4.2 原理

为什么浅拷贝和深拷贝的结果不一样，是因为他们的内存结构导致的，浅拷贝只是复制了当前对象，但是对象里面存在另一个对象的时候是不会去复制的（指向同一个地址），所以当你赋值给该对象stu2的teacher是会导致stu1的teacher跟着变化的

浅拷贝
在这里插入图片描述

深拷贝

在这里插入图片描述
可以看出如果teacher地址不同的话指向的是不同的数据，所以new一个或者利用序列化和序列化都是可以实现的，至于ObjectUtil.cloneByStream方法是如何实现深拷贝的，咱们这里可以看一下源码

    public static <T> T cloneByStream(T obj) {
        if (null != obj && obj instanceof Serializable) {//判断被拷贝对象是否实现了Serializable接口（序列化条件）
            FastByteArrayOutputStream byteOut = new FastByteArrayOutputStream();
            ObjectOutputStream out = null;

            Object var4;
            try {
                out = new ObjectOutputStream(byteOut);
                out.writeObject(obj);//将序列化后的对象写进out
                out.flush();
                ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(byteOut.toByteArray()));//通过byteOut转为字节数组实例化in（输入流）
                var4 = in.readObject(); //var4从输入流in读取对象
            } catch (Exception var8) {
                throw new UtilException(var8);
            } finally {
                IoUtil.close(out);
            }

            return var4;
        } else {
            return null;
        }
    }

为什么要序列化来进行深拷贝，我认为是序列化可以把你整个对象给重新开辟新的空间（包括成员变量）并赋值，这样就能实现深拷贝而且代码也简单，序列化是将对象变为二进制的形式存储，反序列化是把字节序列恢复为对象，这样它是从JVM虚拟机出来又进去，那地址肯定是有变化的。

总结：
浅拷贝只是复制对象（地址不同），而不复制成员属性（引用类型）。
深拷贝是完全复制对象，包括成员属性是引用类型。

有问题欢迎指正，这篇文章我查阅的资料说法不一，我是加了自己的理解去写的。

Black·Tea
关注
Java零拷贝原理介绍
思考的力量
05-18 680
Java零拷贝原理介绍DMA 传输原理传统IO方式零拷贝方式用户态直接 I/Ommap+writeSendfileSendfile+DMA gather copyJava使用零拷贝基于内存映射(mmap)基于sendfileRocketMQ 和 Kafka 零拷贝使用对比 DMA 传输原理 在介绍IO方式前，先介绍以下DMA传输原理。DMA 的全称叫直接内存存取(Direct Memory Access)，是一种允许外围设备(硬件子系统)直接访问系统主内存的机制。也就是说，基于 DMA 访问方式，系统主内存
JAVA对象之克隆-原理分析
jackson0215的专栏
07-01 1160
JAVA对象之克隆   对象的复制可以说是非常普遍的一个问题，当然也是需要注意的一个问题
Java的克隆原理
F_V
02-28 491
今天的记录是java的克隆机制以及深克隆和浅克隆，话不多说，线上代码： public static class Boss{ private int number; public int getNumber() { return number; } public void setNumber(int num...
JAVA -- 对象的克隆操作
最新发布
xycxycooo的博客
07-31 927
浅克隆：通过实现Cloneable接口和重写clone方法实现，适用于基本数据类型的成员变量。深克隆：通过手动复制引用类型的成员变量或使用序列化实现，确保克隆对象和原对象完全独立。通过这些方法，开发者可以根据需求选择合适的克隆方式，实现对象的克隆操作。
java拷贝_深入理解java中的拷贝机制
weixin_34245171的博客
02-12 235
前言众所周知在Java中，拷贝分为深拷贝和浅拷贝两种。java在公共超类Object中实现了一种叫做clone的方法，这种方法clone出来的新对象为浅拷贝，而通过自己定义的clone方法为深拷贝。(一)Object中clone方法如果我们new出一个新对象，用一个声明去引用它，之后又用另一个声明去引用前一个声明，那么最后的结果是：这两个声明的变量将指向同一个对象，一处被改全部被改。如果我们想创建...
解析java克隆、拷贝原理 + 案例解析
weixin_47198217的博客
07-25 312
java拷贝、浅拷贝、深拷贝+例题解析
Java的克隆
qq_21344887的博客
11-04 80
对象的克隆 1.1 变量的 Copy @Data class Person implements Cloneable{ private String name; private int age; public String info(){ return this.getName()+"\t"+this.age; } public Person(String name, int age) { this.name = name
Java 对象拷贝原理剖析及最佳实践
Q54665642ljf的博客
11-25 392
对象拷贝，是我们在开发过程中，绕不开的过程，既存在于 Po、Dto、Do、Vo 各个表现层数据的转换，也存在于系统交互如序列化、反序列化。Java 对象拷贝分为深拷贝和浅拷贝，目前常用的属性拷贝工具，包括 Apache 的 BeanUtils、Spring 的 BeanUtils、Cglib 的 BeanCopier、mapstruct 都是浅拷贝。1.1 深拷贝深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容称为深拷贝。深拷贝常见有以下四种实现方式:构造函数。
java深度克隆
12-17
本文将详细介绍Java中的深度克隆技术，包括其实现原理及应用场景。 #### 二、深度克隆的重要性 在实际开发中，深度克隆具有重要意义： 1. **确保数据独立性**：深度克隆可以创建出与原对象完全独立的新对象，即使...
java：深拷贝与浅拷贝原理与实例
programmer-dll
07-11 598
概念引入：引用拷贝 二者的引用是同一个对象，并没有创建出一个新的对象 因为是同一个对象的引用，所以两者改一个，另一个对象的值也随之改变。 引用拷贝包括浅拷贝与深拷贝 浅拷贝（shallowCopy）：复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象； 深拷贝(deepCopy):复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针和堆内存中的对象 浅拷贝测试代码： class Teacher implem
Java深克隆实现方法
qq_45321888的博客
12-28 4193
引入 Java的Object类中有个clone()方法，我们都知道想要克隆一个对象，只需要实现Cloneable这个标记接口并重写clone()方法即可，但是令人烦恼的是，这个Object类中的clone()方法只能实现浅克隆，即只能将基本类型的值进行复制和引用类型的地址进行复制，没办法将引用类型指向的真正对象进行复制。，这样就导致原来对象和克隆出来的对象共享引用对象，假如一个对象里修改了引用对象，另外一个对象也将会受到影响。 而我们希望的是引用对象也被复制一份，就不用共享了 分析 既然知道了浅克隆的原
深入理解Java中的克隆
09-01
想必大家对克隆都有耳闻，世界上第一只克隆羊多莉就是利用细胞核移植技术将哺乳动物的成年体细胞培育出新个体，甚为神奇。其实在Java中也存在克隆的概念，即实现对象的复制。本文将尝试介绍一些关于Java中的克隆和一些深入的问题，希望可以帮助大家更好地了解克隆。
JAVA对象的值传递clone
weixin_30869099的博客
08-06 93
public class Student implements Cloneable{ private int age; public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override protected Object clo...
Java深克隆和浅克隆的原理和实现
清风不灭的博客
03-11 234
为什么要克隆 首先思考一个问题, 为什么需要克隆对象? 直接new一个对象不行吗? 克隆的对象可能包含一些已经修改过的属性, 而new出来的对象的属性都还是初始化时候的值, 所以当需要一个新的对象来保存当前对象的"状态"时就要靠克隆了. 当然, 把对象的属性一个一个的赋值给新new的对象也是可以的, 但是这样一来麻烦不说, 二来, 我们通过源码查看 Object的clone方法是一个nati...
Java深克隆和浅克隆的原理及实现
lvyuanj的专栏
04-20 1115
通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 student 的 teacher，但是 student1 的 teacher 也被修改了，因为它们都是指向的同一个地址。可以通过hascode打印的值看的出来，引用类型的是相同内存地址，所以修改copy后中teacher.age，直接影响原来student中teacher对象的age。(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。
Java对象拷贝原理剖析及最佳实践
京东科技开发者
11-24 709
对象拷贝，是我们在开发过程中，绕不开的过程，既存在于Po、Dto、Do、Vo各个表现层数据的转换，也存在于系统交互如序列化、反序列化。Java对象拷贝分为深拷贝和浅拷贝，目前常用的属性拷贝工具，包括Apache的BeanUtils、Spring的BeanUtils、Cglib的BeanCopier、mapstruct都是浅拷贝。以上就是我在使用对象拷贝过程中的一点浅谈。在日常系统开发过程中，要深究底层逻辑，哪怕发现一小点的改变能够使我们的系统更加稳定、顺畅，都是值得我们去改进的。
一文搞懂 Java 克隆技术，深拷贝与浅拷贝的区别及实现
m0_71777195的博客
08-03 366
深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是在克隆（Clone）操作中经常遇到的两个概念，它们描述了克隆操作对于对象内部引用的处理方式。浅拷贝（Shallow Copy）：浅拷贝指在克隆操作中，只复制对象本身以及对象内部的基本数据类型的属性，而不复制对象内部的引用类型的属性。浅拷贝仅仅创建了一个新对象，该对象与原始对象共享对同一引用类型属性的访问。如果原始对象的引用类型属性被修改，浅拷贝的对象也会受到影响。
Java Object对象之clone方法
热门推荐
bigconvience的专栏
05-05 3万+
参考文章：点击打开链
Java Object中的clone方法
学亮编程手记
04-16 232
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值