深拷贝和浅拷贝

最新推荐文章于 2024-09-16 21:40:59 发布

shlgyzl

最新推荐文章于 2024-09-16 21:40:59 发布

阅读量145

点赞数 1

本文链接：https://blog.csdn.net/shlgyzl/article/details/92853091

版权

一.背景介绍

1.在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部数据。Java中的对象拷贝主要分为：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

浅拷贝：被拷贝对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝：被拷贝对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

在介绍深拷贝和浅拷贝原理之间的区别前，先介绍下java中的值传递和引用传递：Java中的数据类型分为基本数据类型和引用数据类型。基本数据类型比如说int，double，float等，在对象拷贝过程中，会直接将值进行传递。引用数据类型在对象浅拷贝过程中，会将内存引用地址进行传递，但实际上两个对象的该成员变量都指向同一个实例。因此我们在对象浅拷贝后，如果修改了一个对象的基本数据类型成员属性不会影响另外一个对象的这个成员属性，但由于引用数据类型拷贝的是引用地址，如果修改了这个属性会影响另外一个对象的此属性值，有个例外是String数据类型，它是引用数据类型，但是它存放在常量池中。在java1.8之前常量池是属于方法区的。1.8之后，常量池信息存放在堆中。

这里穿插说下字符串的特殊性。String类的intern()方法：一个初始为空的字符串池，它由类String独自维护。当调用 intern方法时，如果池已经包含一个等于此String对象的字符串（用equals(oject)方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回此String对象的引用。

String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2);

答案为true。采用字面值的方式创建一个字符串时，JVM首先会去字符串池中查找是否存在"abc"这个对象，如果不存在，则在字符串池中创建"abc"这个对象，然后将池中"abc"这个对象的引用地址返回给"abc"对象的引用s1，这样s1会指向池中"abc"这个字符串对象；如果存在，则不创建任何对象，直接将池中"abc"这个对象的地址返回，赋给引用s2。因为s1、s2都是指向同一个字符串池中的"abc"对象，所以结果为true。

因此浅拷贝对象。如果是字符串，一个对象修改了值。如果在常量池中不存在这个字符串，会创建这个字符串。并且将这个字符串的引用复制给这个对象。而不影响另一个对象的这个属性值。

二.如何进行对象的深拷贝

在这里我们介绍下对象深拷贝的俩种方式。

对对象的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。

package linearList;

public class DeepCopy {
public static void main(String[] args) {
Age a=new Age(20);
Student stu1=new Student("张三",a,175);

//通过调用重写后的clone方法进行浅拷贝
Student stu2=(Student)stu1.clone();
System.out.println(stu1.toString());
System.out.println(stu2.toString());
System.out.println();

//尝试修改stu1中的各属性，观察stu2的属性有没有变化
stu1.setName("李四");
//改变age这个引用类型的成员变量的值
a.setAge(99);
//stu1.setAge(new Age(99)); 使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
stu1.setLength(216);
System.out.println(stu1.toString());
System.out.println(stu2.toString());
}
}

/*
* 创建年龄类
*/
class Age implements Cloneable{
//年龄类的成员变量（属性）
private int age;
//构造方法
public Age(int age) {
this.age=age;
}

public int getAge() {
return age;
}

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

public String toString() {
return this.age+"";
}

//重写Object的clone方法
public Object clone() {
Object obj=null;
try {
obj=super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
/*
* 创建学生类
*/
class Student implements Cloneable{
//学生类的成员变量（属性）,其中一个属性为类的对象
private String name;
private Age age;
private int length;
//构造方法,其中一个参数为另一个类的对象
public Student(String name,Age a,int length) {
this.name=name;
this.age=a;
this.length=length;
}
public String getName() {
return name;
}

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

public Age getAge() {
return this.age;
}

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

public int getLength() {
return this.length;
}

public void setLength(int length) {
this.length=length;
}
public String toString() {
return "姓名是： "+this.getName()+"，年龄为： "+this.getaAge().toString()+", 长度是： "+this.getLength();
}
//重写Object类的clone方法
public Object clone() {
Object obj=null;
//调用Object类的clone方法——浅拷贝
try {
obj= super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
//调用Age类的clone方法进行深拷贝
//先将obj转化为学生类实例
Student stu=(Student)obj;
//学生类实例的Age对象属性，调用其clone方法进行拷贝
stu.age=(Age)stu.getAge().clone();
return obj;
}
}

2.实现序列化接口Serializable实现深拷贝

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

/* 通过序列化实现深拷贝 */
public class DeepCopyBySerialization {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Age a=new Age(20);
Student stu1=new Student("张三",a,175);
//通过序列化方法实现深拷贝
ByteArrayOutputStream bos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bos);
oos.writeObject(stu1);
oos.flush();
ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
Student stu2=(Student)ois.readObject();
System.out.println(stu1.toString());
System.out.println(stu2.toString());
System.out.println();
//尝试修改stu1中的各属性，观察stu2的属性有没有变化
stu1.setName("李四");
//改变age这个引用类型的成员变量的值
a.setAge(99);
stu1.setLength(216);
System.out.println(stu1.toString());
System.out.println(stu2.toString());
}
}

/*
* 创建年龄类
*/
class Age implements Serializable{
//年龄类的成员变量（属性）
private int age;
//构造方法
public Age(int age) {
this.age=age;
}

public int getAge() {
return age;
}

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

public String toString() {
return this.age+"";
}
}
/*
* 创建学生类
*/
class Student implements Serializable{
//学生类的成员变量（属性）,其中一个属性为类的对象
private String name;
private Age age;
private int length;
//构造方法,其中一个参数为另一个类的对象
public Student(String name,Age a,int length) {
this.name=name;
this.age=a;
this.length=length;
}
//eclipe中alt+shift+s自动添加所有的set和get方法
public String getName() {
return name;
}