java深度复制和浅度复制

最新推荐文章于 2025-05-30 20:50:41 发布
最新推荐文章于 2025-05-30 20:50:41 发布
阅读量1.3k 收藏 1
点赞数 2
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java string exception object class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/preterhuman_peak/article/details/7719660
本文深入探讨了Java中对象拷贝的两种主要方式：浅复制和深复制，通过实例展示了它们的区别及应用。浅复制仅复制对象本身，而深复制则递归复制对象及其引用的对象。此外，文章还介绍了序列化方法实现深复制的技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

关键字: java 潜拷贝和深拷贝 .java里的clone分为： 
A:浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 
b:深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。 
Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点 
1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。 
2.在派生类的clone()方法中，调用super.clone()。 
3.在派生类中实现Cloneable接口。 

Object类里的clone方法是浅复制（浅克隆） 

浅复制（浅克隆）的例子如下：

package com.test;

//浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
//深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。
//
//Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点
//1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
//2.在派生类的clone()方法中，调用super.clone()。
//3.在派生类中实现Cloneable接口。

//<SPAN style="COLOR: red">Object类里的clone方法是浅复制（浅克隆）</SPAN>public class CloneTest {

 public static void main(String[] args) throws Exception{
  //teacher对象将被clone出来的Student对象共享.
  Teacher teacher = new Teacher();
  teacher.setAge(40);
  teacher.setName("Teacher zhang");
  
  Student student1 = new Student();
  student1.setAge(20);
  student1.setName("zhangsan");
  student1.setTeacher(teacher);
  
  //复制出来一个对象student2
  Student student2 = (Student)student1.clone();
  System.out.println(student2.getAge());
  System.out.println(student2.getName());
  
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
  
  
  //修改student2的引用对象
  student2.getTeacher().setAge(50);
  student2.getTeacher().setName("Teacher Li");
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
 }
}

class Teacher {
 public int age;
 public String name;
 
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
 
}

class Student implements Cloneable{
 
 public int age ;
 public String name;
 public Teacher teacher;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Teacher getTeacher() {
  return teacher;
 }
 public void setTeacher(Teacher teacher) {
  this.teacher = teacher;
 }
 @Override
 public Object clone() throws CloneNotSupportedException {
  return super.clone();
 }
 
 
}
输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
50
Teacher Li
2.深复制（深Clone）例子：

package com.test1;

//深clone
public class DeepCloneTest {

 public static void main(String[] args) throws Exception{
  //teacher对象将不被clone出来的Student对象共享.
  Teacher teacher = new Teacher();
  teacher.setAge(40);
  teacher.setName("Teacher zhang");
  
  Student student1 = new Student();
  student1.setAge(20);
  student1.setName("zhangsan");
  student1.setTeacher(teacher);
  
  //复制出来一个对象student2
  Student student2 = (Student)student1.clone();
  System.out.println(student2.getAge());
  System.out.println(student2.getName());
  
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
  
  
  //修改student2的引用对象
  student2.getTeacher().setAge(50);
  student2.getTeacher().setName("Teacher Li");
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
 }
}

class Teacher implements Cloneable{
 public int age;
 public String name;
 
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 @Override
 public Object clone() throws CloneNotSupportedException {
  return super.clone();
 }
 
}

class Student implements Cloneable{
 
 public int age ;
 public String name;
 public Teacher teacher;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Teacher getTeacher() {
  return teacher;
 }
 public void setTeacher(Teacher teacher) {
  this.teacher = teacher;
 }
 @Override
 public Object clone() throws CloneNotSupportedException {
  Student student = (Student)super.clone();
  //将引用的对象teacher也clone下
  student.setTeacher((Teacher)(student.getTeacher().clone()));
  return student;
 }
 
 
}
输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
3.利用序列化来做深复制,把对象写到流里的过程是序列化（Serilization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。，利用这个特性，可以做深拷贝

package com.test3;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//利用序列化来做深复制
//深clone
public class DeepCloneTest {

 public static void main(String[] args) throws Exception{
  //teacher对象将不被clone出来的Student对象共享.
  Teacher teacher = new Teacher();
  teacher.setAge(40);
  teacher.setName("Teacher zhang");
  
  Student student1 = new Student();
  student1.setAge(20);
  student1.setName("zhangsan");
  student1.setTeacher(teacher);
  
  //复制出来一个对象student2
  Student student2 = (Student)student1.deepCopy();
  System.out.println(student2.getAge());
  System.out.println(student2.getName());
  
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
  
  
  //修改student2的引用对象
  student2.getTeacher().setAge(50);
  student2.getTeacher().setName("Teacher Li");
  
  System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
  System.out.println(student1.getTeacher().getAge());
  System.out.println(student1.getTeacher().getName());
 }
}

class Teacher implements Serializable{
 
 private static final long serialVersionUID = -8834559347461591191L;
 
 public int age;
 public String name;
 
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
}

class Student implements Serializable{
 
 //serialVersionUID 如果你的对象序列化后存到硬盘上面后，可是后来你却更改了类的field(增加或减少或改名)，当你反序列化时，就会出现Exception的，这样就会造成不兼容性的问题。 
 //但当serialVersionUID相同时，它就会将不一样的field以type的缺省值赋值(如int型的是0,String型的是null等)，这个可以避开不兼容性的问题。所以最好给serialVersionUID赋值
 private static final long serialVersionUID = 7991552226614088458L;
 
 public int age ;
 public String name;
 public Teacher teacher;
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Teacher getTeacher() {
  return teacher;
 }
 public void setTeacher(Teacher teacher) {
  this.teacher = teacher;
 }
 
 public Object deepCopy() throws Exception{
  //将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
  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();
 }
 
 
}
输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang

解析JAVA深度克隆与浅度克隆的区别详解
09-05
Java提供了两种主要的克隆方式：浅度克隆（Shallow Clone）和深度克隆（Deep Clone）。理解这两种克隆的区别对于优化内存管理和复制复杂对象至关重要。 **浅度克隆（Shallow Clone）** 浅度克隆仅仅复制了对象本身...
java clone
ttitfly的笔记
01-13 147
1.java里的clone分为： A:浅复制（浅克隆）: [color=red]浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。[/color] b:深复制（深克隆）：[color=red]深复制把要复制的对象所引用的对象都复制了一遍。[/color] Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点 1.在派生类中覆盖基...
赋值、浅拷贝和深拷贝（数组和对象的深浅拷贝）
xiasohuai的博客
07-26 4921
深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。  浅拷贝 只是拷贝了基本类型的数据，而引用类型数据，复制后也是会发生引用，我们把这种拷贝叫做浅拷贝（浅复制） 浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。 赋值和浅拷贝的区别 当我们把一个对象赋值...
【Java第68集】java对象深拷贝与浅拷贝详解
最新发布
一步一个脚印，冲冲冲。
05-30 1245
浅拷贝：仅复制引用字段地址，适合简单对象或共享引用场景。深拷贝：递归复制所有引用对象，适合复杂对象或需完全独立副本的场景。实现方式：可通过clone()、序列化或手动递归复制实现深拷贝。最佳实践：根据需求选择合适方法，权衡性能与安全性，避免常见错误。
最简单的深拷贝_飘云羽逸_新浪博客
飘云羽逸
10-16 333
package com.leitan.architect.pattern.prototype.deep;import java.io.*;import java.util.Date;public class QiTianDaSheng extends Monkey implements Cloneable, Serializable { public JinGuBang ji...
ios 深浅拷贝学习
yohohohoho的专栏
09-24 459
这里主要侧重于集合类的深浅拷贝，主要事因为工作的时候遇到这个问题。 有不足的地方欢迎指正，转载请注明。 首先我们需要有这样的一个前提：   ［array addObject:obj]; 这样obj的引用计数会增加1，如果使用remove则obj的引用计数会减一。
Java 深拷贝和浅拷贝
weixin_34087503的博客
03-08 125
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
Java高效对象克隆框架：深度与浅度克隆支持
从给定的文件信息中，我们可以提取和展开关于Java对象克隆技术的多个知识点。以下是对标题、描述和标签中所述内容的知识点详细说明。 ### Java对象克隆技术 #### 1. 对象克隆的定义和类型 在Java中，对象克隆是一...
Java深度克隆实现与Car类Engine类关系探究
本知识点将围绕Java中的可克隆性进行深入讲解，包括如何在Java类中实现克隆方法，以及如何通过覆盖clone()和toString()方法来确保对象的深度克隆。 1. Java中的克隆机制： Java通过实现Cloneable接口以及覆盖Object...
java list深度拷贝
04-29
List拥有深度拷贝和浅度拷贝两种方式。 深度拷贝是指在将一个List复制到另一个List时，不仅复制了List本身，而且复制了List中所有元素的值。这样生成的新List是与原List完全独立的，修改新List不会影响原List，反之...
深复制与浅复制
weixin_61558111的博客
06-12 3518
浅拷贝：只创建一个新的指针，指向原指针指向的内存 深拷贝：创建一个新的指针，并开辟新的内存空间，内容拷贝自原指针指向的内存，并指向它 假设我们要对一个不可变的对象进行不可变copy（原来的对象不可变，新对象也不可变）。就没必要给新对象新建一块内存，反正大家都不可以对这个对象进行改变，那都使用一个就可以。所以iOS系统规定浅拷贝引用计数器加1就行。而需要给新对象开闭内存空间的，就是深拷贝。浅拷贝即指针拷贝，可以认为是给一只狗加了一条绳子；深拷贝不但拷贝了对象的指针，还在系统中在分配了一块内存用来存放拷贝对象的
深度复制和浅度复制
qq_37361514的博客
08-15 758
有一个地方需要注意的是：实体类我们用的是Lombok的@Data注解，修改前equals返回的是true，但是通过上面的内容我们可以了解，两个对象的内存地址和引用地址都不相同，可以判断Lombok中重写了equals方法；注意：这里使用的是spring的BeanUtils类，不是Apache的，Apache的这个方法性能较差，具体的分析可查看下面地址的文档。可以看到两个类的地址并不相同，用==进行比较也是false，说明这两个类的内存地址不同，引用地址也不同，是深度复制；回归正题，直接上测试代码。...
NET深入学习笔记(4):深拷贝与浅拷贝(Deep Copy and Shallow Copy)
zhongjie的专栏
07-10 813
None
Java深拷贝
不夜城的油条的博客
11-27 286
public class DeepCopy { public static Object copy(Object orig) throws NotSerializableException { Object obj = null; try { // Write the object out to a byte array ...
java深拷贝
shuangyueliao的专栏
12-09 443
【代码】java深拷贝。
java设计模式(2)原型模式
qq_41249465的博客
10-18 170
java设计模式(2) 原型模式 1.前言 原型模式：原型模式是指用原型实例来创建对象的种类，并且通过拷贝这些原型，创建新的对象 原型模式是一种创建型设计模式，它允许一个对象创建另外一个对象，不用知道细节 工作原理：通过一个原型对象传给那个要发动穿件的对象，这个要发动创建的对象通过请求原型对象拷贝他们来创建自己，即,对象.clone() 解释说明 Prorotype:原型，声明一个clone自...
OpenCVSharp的Mat深度复制和浅度复制
01-22
### OpenCVSharp 中 Mat 对象的深拷贝与浅拷贝 #### 浅拷贝 在 OpenCVSharp 中，当使用 `=` 运算符来复制一个 `Mat` 对象时，默认情况下会创建该对象的一个浅拷贝。这意味着两个变量实际上指向同一块内存区域。如果修改其中一个变量的内容，另一个也会受到影响。 ```csharp using (var img1 = Cv2.ImRead("image.jpg")) { using (var img2 = img1) // 创建了一个浅拷贝 { // 修改 img1 将会影响 img2 img1.SetTo(Scalar.Red); // 显示图像 Cv2.ImShow("Original Image", img1); Cv2.ImShow("Shallow Copy", img2); Cv2.WaitKey(0); } } ``` #### 深拷贝 为了实现真正的数据隔离，即创建一个新的独立副本而不共享底层的数据缓冲区，可以使用 `.Clone()` 方法或 `.CopyTo()` 函数来进行深拷贝操作。这两种方式都会分配新的内存并复制原始图像的所有像素值到新位置上[^2]。 - **`.Clone()`**: 总是会在堆栈中开辟一块全新的连续存储空间用于保存完整的图像信息，并返回这个新实例。 ```csharp using (var img1 = Cv2.ImRead("image.jpg")) { var img2 = img1.Clone(); // 完整的深拷贝 // 即使现在改变 img1 的内容也不会影响到 img2 img1.SetTo(Scalar.Blue); // 展示两幅图的不同状态 Cv2.ImShow("Modified Original", img1); Cv2.ImShow("Deep Copied Version", img2); Cv2.WaitKey(0); } ``` - **`.CopyTo(Mat dst)`**: 此方法允许指定目标容器（dst），它可以根据目的端的具体情况决定是否重新分配内存。如果目标容器已经存在并且尺寸合适，则可以直接覆盖其内部数据；反之则需先调整大小再执行复制过程[^4]。 ```csharp using (var srcImg = Cv2.ImRead("source_image.jpg")) { using (var destImg = new Mat()) { srcImg.CopyTo(destImg); // 如果destImg为空或者尺寸不合适将会被重置为合适的尺寸 // 可以安全地对源图片做任何更改而不用担心会影响到目的地 srcImg.SetTo(Scalar.Green); Cv2.ImShow("Source After Modification", srcImg); Cv2.ImShow("Destination Unchanged By Source Changes", destImg); Cv2.WaitKey(0); } } ``` 综上所述，在处理多份相同但又希望保持各自独立性的图像资料时，应当优先考虑采用深拷贝的方式以避免不必要的副作用[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值