文章目录
目录
文章目录
前言
1) 引用拷贝
2) 对象拷贝
二 . 浅拷贝
1) 拷贝构造方法实现浅拷贝
2) 工厂方法实现浅拷贝
3) clone方法实现浅拷贝
三 . 深拷贝
1) 通过重写clone方法来实现深拷贝
2) 通过对象序列化实现深拷贝
前言
大家好,今天给大家带来的是java中的深浅拷贝
一 . 拷贝的引入
1) 引用拷贝
引用拷贝通常指的是浅拷贝，即只复制了对象本身，而没有复制对象内部的引用对象。这意味着原始对象和拷贝对象仍然共享相同的引用对象
创建一个指向对象的引用变量的拷贝对象
Student s1 = new Student("张三",23);
Student s2 = s1;
System.out.println(s1);
System.out.println(s2);
2) 对象拷贝
创建对象本身的一个副本。
Student student = new Student("张三",23);
Student otherStudent = (Student)student.clone();
System.out.println(student);
System.out.println(otherStudent);
结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。
Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。
在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。
Java中的对象拷贝主要分为：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。
二 . 浅拷贝
浅拷贝是指在拷贝对象时，只复制对象本身，而不复制对象内部的引用对象。这意味着原始对象和拷贝对象会共享相同的引用对象，如果引用对象发生改变，原始对象和拷贝对象都会受到影响。
①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
②对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。
在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
浅拷贝的实现方式主要有三种
1) 拷贝构造方法实现浅拷贝
class Person {Age age;String name;public Person(Age age, String name) {this.age = age;this.name = name;}/*** 拷贝构造方法* @param p*/public Person(Person p){this.age = p.age;this.name = p.name;}}class Age{int age;public Age(int age) {this.age = age;}
}Age age = new Age(18); Person person1 = new Person(age,"张三"); Person person2 = new Person(person1); System.out.println(person1); System.out.println(person2);
2) 工厂方法实现浅拷贝
改变一个方法就行,其他的不变
/*** 工厂方法* @param p*/public Person clone(Person p){return new Person(p.age,p.name);}3) clone方法实现浅拷贝
Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。有了这个浅拷贝模板，我们可以通过调用clone()方法来实现对象的浅拷贝。
但是需要注意：
1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。
对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法
public class ShallowCopy {public static void main(String[] args) throws CloneNotSupportedException {Age age = new Age(18);Person person1 = new Person(age,"张三");Person person2 = (Person)person1.clone();System.out.println(person1);System.out.println(person2);}
}class Person implements Cloneable{Age age;String name;public Person(Age age, String name) {this.age = age;this.name = name;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}class Age{int age;public Age(int age) {this.age = age;}
}三 . 深拷贝
深拷贝指的是在复制对象时，不仅复制了对象本身，还复制了对象内部的所有引用对象，使得原始对象和拷贝对象完全独立，彼此不会相互影响。
在进行深拷贝时，需要递归地复制对象及其内部的所有引用对象，确保每个对象都是独立的
浅拷贝示意图
深拷贝示意图
如果Age对象依然关联其他引用对象,同样也是需要拷贝的
深拷贝的实现方法主要有两种
1) 通过重写clone方法来实现深拷贝
class Animal implements Cloneable{int age;String name;Dog dog;public Animal(int age, String name, Dog dog) {this.age = age;this.name = name;this.dog = dog;}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 Dog getDog() {return dog;}public void setDog(Dog dog) {this.dog = dog;}@Overrideprotected Object clone() throws CloneNotSupportedException {Animal animal = (Animal)super.clone();animal.setDog((Dog)animal.getDog().clone());return animal;}
}class Dog implements Cloneable{int age;String name;public Dog(int age, String name) {this.age = age;this.name = name;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}Animal animal = new Animal(1,"小黄",new Dog(1,"小黄")); Animal cloneAnimal = (Animal) animal.clone(); System.out.println(animal); System.out.println(cloneAnimal); System.out.println(animal.getDog()); System.out.println(cloneAnimal.getDog());
结果分析 : 两个引用animal和cloneAnimal指向不同的两个对象，两个引用animal和cloneAnimal中的两个Dog引用指向的是两个对象，但对Dog对象的修改只能影响animal对象,所以说是深拷贝。
2) 通过对象序列化实现深拷贝
虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。
将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。
参考代码如下
import java.io.*;class MyClass implements Serializable {int number;public MyClass(int number) {this.number = number;}
}public class DeepCopyExample {public static void main(String[] args) {// 创建一个原始对象MyClass originalObject = new MyClass(10);// 使用序列化和反序列化进行深拷贝MyClass copiedObject = deepCopy(originalObject);// 修改原始对象的值originalObject.number = 20;// 打印拷贝对象的值，验证是否进行了深拷贝System.out.println(copiedObject.number); // 输出 10}// 使用序列化和反序列化进行深拷贝public static <T extends Serializable> T deepCopy(T object) {try {ByteArrayOutputStream outputStream = new ByteArrayOutputStream();ObjectOutputStream output = new ObjectOutputStream(outputStream);output.writeObject(object);ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());ObjectInputStream input = new ObjectInputStream(inputStream);return (T) input.readObject();} catch (Exception e) {e.printStackTrace();return null;}}
}总结
这篇文章这要给大家介绍了一下java中的深浅拷贝,我们下一篇博客见
