深拷贝和浅拷贝(完整实例)

最新推荐文章于 2024-04-22 20:48:08 发布
最新推荐文章于 2024-04-22 20:48:08 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/atu1111/article/details/105367571
版权

深拷贝和浅拷贝

  1、浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。

在这里插入图片描述

  2、深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

在这里插入图片描述

  3、浅拷贝(clone)示例代码

public class Student implements Cloneable
{
    private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	
	@Override
	public Object clone() throws CloneNotSupportedException
	{
		return super.clone();
	}
	
	
}

public class Teacher implements Cloneable
{
	    private String name;
        private Student student;
		public String getName() {
			return name;
		}

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

		public Student getStudent() {
			return student;
		}

		public void setStudent(Student student) {
			this.student = student;
		}
		

		@Override
		public String toString() {
			return "Teacher [name=" + name + ", student=" + student + "]";
		}
		@Override
		public Object clone() throws CloneNotSupportedException
		{
			return super.clone();
		}
		
		
}


public class Test 
{
    public static void main(String[] args) 
    {
		Teacher wangLaoShi = new Teacher();
		wangLaoShi.setName("王");
		Student student1 = new Student();
		student1.setName("张三");
		wangLaoShi.setStudent(student1);
		System.out.println();
		
		// 打印结果一样 初步证明使用clone浅拷贝成功
		Teacher xLaoShi = new Teacher();
		try 
		{
			xLaoShi = (Teacher) wangLaoShi.clone();
		} catch (CloneNotSupportedException e)
		{
			e.printStackTrace();
		}
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
	    /*
			Teacher [name=王, student=Student [name=张三]]
			Teacher [name=王, student=Student [name=张三]]
	     */
		
		
		// 修改原老师的姓名和学生的姓名，复制的x老师的老师姓名没有跟着变化，学生姓名跟着原老师的学生姓名变化，证明是浅拷贝。
		wangLaoShi.setName("张");
		wangLaoShi.getStudent().setName("李四");
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
		
	    /*
			Teacher [name=王, student=Student [name=李四]]
            Teacher [name=张, student=Student [name=李四]]
	     */
	}
}

  4、深拷贝(clone)示例代码

public class Student implements Cloneable
{
    private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	
	@Override
	public Student clone() throws CloneNotSupportedException
	{
		return (Student)super.clone();
	}
	
	
}


public class Teacher implements Cloneable
{
	    private String name;
        private Student student;
		public String getName() {
			return name;
		}

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

		public Student getStudent() {
			return student;
		}

		public void setStudent(Student student) {
			this.student = student;
		}
		

		@Override
		public String toString() {
			return "Teacher [name=" + name + ", student=" + student + "]";
		}
		@Override
		public Teacher clone() throws CloneNotSupportedException
		{
			Teacher teacher = (Teacher) super.clone();
			teacher.setStudent((Student)teacher.getStudent().clone());
			return teacher;
		}
		
		
}


public class Test 
{
    public static void main(String[] args) 
    {
		Teacher wangLaoShi = new Teacher();
		wangLaoShi.setName("王");
		Student student1 = new Student();
		student1.setName("张三");
		wangLaoShi.setStudent(student1);
		System.out.println();
		
		// 打印结果一样 初步证明使用clone深拷贝成功
		Teacher xLaoShi = new Teacher();
		try 
		{
			xLaoShi = wangLaoShi.clone();
		} catch (CloneNotSupportedException e)
		{
			e.printStackTrace();
		}
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
	    /*
			Teacher [name=王, student=Student [name=张三]]
			Teacher [name=王, student=Student [name=张三]]
	     */
		
		
		// 修改原老师的姓名和学生的姓名，复制的x老师的老师姓名，学生姓名没有跟着变化，证明是深拷贝。
		wangLaoShi.setName("张");
		wangLaoShi.getStudent().setName("李四");
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
		
	    /*
		    Teacher [name=王, student=Student [name=张三]]
            Teacher [name=张, student=Student [name=李四]]
	     */
	}
}

  5、深拷贝(序列化)示例代码

public class Student implements Serializable
{
    /**
	 * 
	 */
	private static final long serialVersionUID = 2808612254630368408L;
	
	private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	
	
	
}


public class Teacher  implements Serializable
{
	    /**
	    * 
	    */
	    private static final long serialVersionUID = 3337955056649739635L;
		private String name;
        private Student student;
		public String getName() {
			return name;
		}

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

		public Student getStudent() {
			return student;
		}

		public void setStudent(Student student) {
			this.student = student;
		}
		

		@Override
		public String toString() {
			return "Teacher [name=" + name + ", student=" + student + "]";
		}

		
		
}


public class Test 
{
    @SuppressWarnings("resource")
	public static void main(String[] args) 
    {
		Teacher wangLaoShi = new Teacher();
		wangLaoShi.setName("王");
		Student student1 = new Student();
		student1.setName("张三");
		wangLaoShi.setStudent(student1);
		System.out.println();
		try 
		{
			//序列化
			OutputStream outputStream = new FileOutputStream(new File("E:/Teacher.txt"));
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
			objectOutputStream.writeObject(wangLaoShi);
			
			//反序列化
			InputStream inputStream = new FileInputStream(new File("E:/Teacher.txt"));
			ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
			Teacher xLaoShi = (Teacher) objectInputStream.readObject();
			
			//打印结果一样 初步证明序列化深拷贝成功
			System.out.println(xLaoShi);
			System.out.println(wangLaoShi);
			 /*
					Teacher [name=王, student=Student [name=张三]]
					Teacher [name=王, student=Student [name=张三]]
		     */
			
			// 修改原老师的姓名和学生，复制的x老师，没有跟着变化，证明使用序列化深拷贝成功。
			wangLaoShi.setName("张");
			wangLaoShi.getStudent().setName("李四");
			System.out.println(xLaoShi);
			System.out.println(wangLaoShi);
			
		    /*
				Teacher [name=王, student=Student [name=张三]]
	            Teacher [name=张, student=Student [name=李四]]
		     */
			
			
			
		} catch (Exception e) 
		{
			e.printStackTrace();
		}
	
	 
	}
}

  6、深拷贝(自定义)示例代码

public class Student 
{
    private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	
	
}


public class Teacher 
{
	    private String name;
        private Student student;
		public String getName() {
			return name;
		}

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

		public Student getStudent() {
			return student;
		}

		public void setStudent(Student student) {
			this.student = student;
		}
		
		public Teacher copy(Teacher teacher)
		{
			 Student student = new Student();
			 student.setName(teacher.getStudent().getName());
			 this.student = student;
			 this.name = teacher.getName();
			 return teacher;
		}

		@Override
		public String toString() {
			return "Teacher [name=" + name + ", student=" + student + "]";
		}
		
		
}


public class Test 
{
    public static void main(String[] args) 
    {
		Teacher wangLaoShi = new Teacher();
		wangLaoShi.setName("王");
		Student student1 = new Student();
		student1.setName("张三");
		wangLaoShi.setStudent(student1);
		System.out.println();
		
		// 打印结果一样 初步证明自定义深拷贝成功
		Teacher xLaoShi = new Teacher();
		xLaoShi.copy(wangLaoShi);
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
	    /*
			Teacher [name=王, student=Student [name=张三]]
			Teacher [name=王, student=Student [name=张三]]
	     */
		
		
		// 修改原老师的姓名和学生，复制的x老师，没有跟着变化，证明自定义深拷贝成功。
		wangLaoShi.setName("张");
		wangLaoShi.getStudent().setName("李四");
		System.out.println(xLaoShi);
		System.out.println(wangLaoShi);
		
	    /*
			Teacher [name=王, student=Student [name=张三]]
            Teacher [name=张, student=Student [name=李四]]
	     */
	}
}
闲人不梦卿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深拷贝（什么是深拷贝，为什么要进行深拷贝，如何进行深拷贝（至少写三种方法，手写深拷贝））
fengshaopu的博客
05-23 3597
加粗样式一、什么是深拷贝、浅拷贝 深拷贝和浅拷贝是针对复杂数据类型来说的，浅拷贝只拷贝一层，而深拷贝是层层拷贝。 1.浅拷贝： 将原对象或原数组的引用直接赋给新对象，新数组，新对象只是对原对象的一个引用 2.深拷贝： 创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用” 二、为什么要进行深拷贝 我们想要的结果是两个变量（初始值相同）互不影响。所以就要使用到拷贝（分为深浅两种） 三、深拷贝(三中方法) 1.使用递归的方式实现深拷贝 //使用递归的方式实现数组、对
C#浅拷贝和深拷贝实例解析
09-04
在C#编程中，浅拷贝和深拷贝是两种不同的对象复制机制，它们涉及到对象内存管理和引用处理。本文将详细解析这两种拷贝方式的区别和使用场景。 **浅拷贝（Shallow Copy）** 浅拷贝是指创建一个新对象，然后将原始...
基础面试题:深拷贝和浅拷贝详解以及实例
热门推荐
Venus's Blog
04-30 4万+
深拷贝 vs 浅拷贝 浅拷贝 概念 复制基本类型的属性；引用类型的属性复制，复制栈中的变量 和 变量指向堆内存中的对象的指针，不复制堆内存中的对象。 如图： ​ 特点 ​ 1.对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。 2.对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝...
浅拷贝和深拷贝「详解 附代码」
2301_79449186的博客
04-22 288
当对象成员中无指针或引用时,浅拷贝与深拷贝相同,可以互用.
浅拷贝和深拷贝---使用举例子法生动讲述
PCGuo999的博客
04-29 914
使用举例子的方法对浅拷贝和深拷贝的含义以及使用进行生动形象的讲解，让你可以生动了解它们
浅拷贝和深拷贝(代码详解)
吾头一坨铁的博客
05-30 847
分析: 浅拷贝只是拷贝一层,深拷贝可拷贝多层 意思就是一个对象里面有普通数据和对象或者数组,现在要拷贝它 浅拷贝就是拷贝普通数据和数组对象的地址,因为地址指向的是同一个所以拷贝之后,修改数组或者对象的数据,拷贝和被拷贝的都会发生变化. 深拷贝是拷贝了一个对象的所有内容,但是它是独立的,指向不同的地址. 浅拷贝: (1) 使用循环拷贝 (2)使用Object.assign()拷贝(es6中的) var names = { a: "javascript", b:
深拷贝的五种实现方式
Z_J_CSDN的博客
07-08 3万+
深拷贝的几种实现方式
深拷贝、浅拷贝的方法
weixin_51225684的博客
12-01 3833
/这个方法可以，只不过function和undefined这种情况下无法复制。函数库lodash，也有提供_.cloneDeep用来做深拷贝。接下来我们就以下面这个obj1对象为例子，进行深浅拷贝的演示。1.写一个递归(推荐，比较完美的解决方案)封装一个DeepClone的深拷贝函数。4.JSON转换方法。
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
本文实例讲述了JavaScript深拷贝和浅拷贝概念与用法。分享给大家供大家参考，具体如下： js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础...
Python浅拷贝与深拷贝用法实例
12-25
本文实例讲述了Python浅拷贝与深拷贝用法。分享给大家供大家参考。具体分析如下： >>> person=['name',['savings',100]] >>> hubby=person[:] >>> wifey=list(person) >>> [id(x) for x in person,hubby,wifey] ...
Python深拷贝与浅拷贝用法实例分析
12-31
本文实例讲述了Python深拷贝与浅拷贝用法。分享给大家供大家参考，具体如下： 1、对象的赋值 对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个...
Java中的深拷贝(深复制)和浅拷贝(浅复制) 示例代码
05-12
Java关于深拷贝(深复制)和浅拷贝(浅复制)比较通俗易懂的简单说明及示例代码...
深拷贝/浅拷贝精讲
总结分享
05-19 702
浅拷贝 vs 深拷贝
浅谈深拷贝 内附超好用的深拷贝方法
jinse29的博客
08-15 518
浅拷贝：创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。 深拷贝： 将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。...
【javascript】详解javaScript的深拷贝
weixin_33862993的博客
08-14 472
      前言： 最开始意识到深拷贝的重要性是在我使用redux的时候（react + redux）， redux的机制要求在reducer中必须返回一个新的对象，而不能对原来的对象做改动，事实上，当时我当然不会主动犯这个错误，但很多时候，一不小心可能就会修改了原来的对象，例如：var newObj = obj; newObj.xxx = xxx  实际上，这个时候newObj和obj两个...
JS浅谈深拷贝和浅拷贝
qq_36091581的博客
01-23 1739
JS浅谈深拷贝和浅拷贝 在前端面试中经常会问到如何理解JS的深浅拷贝，又是如何实现的？ 今天我们通过几个例子来理解一下。 浅拷贝 简单点来说，就是假设B复制了A，当修改A时，看B是否会发生变化，如果B也跟着变了。 下面我会引用到栈堆方面的内容来加强理解。 例： let a=[0,1,2,3,4], b=a; console.log(a===b); a[0]=1; co
Java的深拷贝的例子
积跬步 至千里
01-09 702
@Test public void deepCopy() throws Exception { Map<String, Set<Integer>> oldMap = new HashMap<>(); Set<Integer>
浅拷贝，深拷贝，隐式共享的三个例子
z278930050的专栏
12-19 1369
1.浅拷贝：    浅拷贝就比如像引用类型    浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。 2.深拷贝：    而深拷贝就比如值类型。   深拷贝是指源对象与拷贝对象互
深拷贝和浅拷贝示例
weixin_34023863的博客
12-11 103
关于深拷贝和浅拷贝的文章已经颇多。http://cnn237111.blog.51cto.com/2359144/589507 简单的说，深拷贝和浅拷贝都是拷贝对象。但是当拷贝的对象中有包含引用类型对象时，深拷贝和浅拷贝的做法就又不一样了。 浅拷贝对该子对象只是拷贝了一个引用，实际上指向的还是拷贝对象的那份数据。 深拷贝则不然，是重新开辟内存空间，将子对象玩玩整整的复制一份。 下面是一个演...
C++浅拷贝和深拷贝的实例
最新发布
04-26
在 C++ 中，当一个类的对象被复制时，有两种拷贝方式：浅拷贝和深拷贝。 浅拷贝是指将一个对象的数据成员逐个地复制到另一个对象中，这样两个对象共享同一块内存空间。如果其中一个对象修改了这块内存，那么另一个对象也会受到影响。 深拷贝是指将一个对象的数据成员逐个地复制到另一个对象中，但是对于指针类型的数据成员，会为它们分配新的内存空间，并将原来指针指向的内容复制到新的内存空间中。这样两个对象拥有独立的内存空间，彼此之间互不干扰。 以下是一个浅拷贝和深拷贝的实例： ```cpp #include <iostream> #include <cstring> class Person { public: Person(const char* n, int a) : age(a) { name = new char[strlen(n) + 1]; strcpy(name, n); } // 拷贝构造函数 Person(const Person& other) { age = other.age; name = other.name; } // 析构函数 ~Person() { delete[] name; } // 输出信息 void printInfo() { std::cout << "Name: " << name << ", Age: " << age << std::endl; } private: char* name; int age; }; int main() { Person p1("Tom", 20); Person p2 = p1; // 浅拷贝 p1.printInfo(); // 输出 "Name: Tom, Age: 20" p2.printInfo(); // 输出 "Name: Tom, Age: 20" p1.~Person(); // 销毁 p1 的 name 指针 p2.printInfo(); // 输出 "Name: Tom, Age: 20"，name 指针已被销毁，p2 中的 name 指针变成了野指针 return 0; } ``` 上述代码中，我们定义了一个 Person 类，其中有一个字符串类型的数据成员 name。在拷贝构造函数中，我们只是简单地将 age 和 name 的值从一个对象复制到了另一个对象中，这是一种浅拷贝。当 p1 被销毁时，它的 name 指针被释放了。由于 p2 和 p1 共享同一块内存空间，所以当 p2.printInfo() 被调用时，name 指针已经被销毁，p2 中的 name 指针变成了野指针。 接下来是深拷贝实现： ```cpp #include <iostream> #include <cstring> class Person { public: Person(const char* n, int a) : age(a) { name = new char[strlen(n) + 1]; strcpy(name, n); } // 拷贝构造函数 Person(const Person& other) { age = other.age; name = new char[strlen(other.name) + 1]; strcpy(name, other.name); } // 析构函数 ~Person() { delete[] name; } // 输出信息 void printInfo() { std::cout << "Name: " << name << ", Age: " << age << std::endl; } private: char* name; int age; }; int main() { Person p1("Tom", 20); Person p2 = p1; // 深拷贝 p1.printInfo(); // 输出 "Name: Tom, Age: 20" p2.printInfo(); // 输出 "Name: Tom, Age: 20" p1.~Person(); // 销毁 p1 的 name 指针 p2.printInfo(); // 输出 "Name: Tom, Age: 20"，name 指针已经被复制，不会出现野指针 return 0; } ``` 上述代码中，在拷贝构造函数中我们不仅将 age 和 name 的值从一个对象复制到了另一个对象中，还为 name 分配了新的内存空间，并将原来指针指向的内容复制到新的内存空间中。这样两个对象拥有独立的内存空间，彼此之间互不干扰。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值