“深入探讨Java中的对象拷贝：浅拷贝与深拷贝的差异与应用“ ...

        前言：在Java编程中，深拷贝（Deep Copy）与浅拷贝（Shallow Copy）是两个非常紧张的概念。它们涉及到对象在内存中的复制方式，对于理解对象的引用、内存管理以及数据安全都至关紧张。

---

   

  ✨✨✨这里是秋刀鱼不做梦的BLOG
  ✨✨✨想要了解更多内容可以访问我的主页秋刀鱼不做梦-CSDN博客
  先让我们看一下本文的大致内容：

目录
1.深拷贝与浅拷贝的概念
（1）浅拷贝
（2）深拷贝
2.浅拷贝的实现
3.深拷贝的实现
4.深浅拷贝的作用
浅拷贝的作用：
深拷贝的作用：

---

1.深拷贝与浅拷贝的概念

        ——在了解Java中是如何实现对象的深浅拷贝之前，我们须要先了解一下什么是深拷贝、浅拷贝：

（1）浅拷贝

           在浅拷贝中，只复制对象自己，而不复制对象引用的内容。这意味着，如果对象中包含了引用范例的成员变量，那么这些成员变量的引用将会被复制，但是它们仍然指向相同的内存地址。因此，对于引用范例成员变量的修改会影响到原始对象和拷贝对象。
  （2）深拷贝

           与浅拷贝差别，深拷贝会递归地复制对象及其全部引用的对象，直到全部对象都被复制到一个新的内存地址上。这样，原始对象和拷贝对象完全独立，相互的修改不会相互影响。
          嗯嗯嗯......感觉看了和没看没什么区别，还是不太能理解到底什么是Java中的深浅拷贝，那么我们使用一个生存中的案例来解释一下：
浅拷贝的景象：
        ——如果你选择了浅拷贝，那么你会简单地把整个礼物篮进行复制，然后送给你的朋侪。在这种情况下，你的朋侪会得到一个看起来一模一样的礼物篮。然而，当你的朋侪拆开礼物篮，他们发现内里的食品和饰品并没有改变，他们是和你的礼物篮里的相同的食品和饰品。

深拷贝的景象：
        ——相比之下，如果你选择了深拷贝，那么你会仔细地把礼物篮里的每一样东西都复制一份，然后把这些复制品装进一个新的礼物篮里，送给你的朋侪。在这种情况下，你的朋侪得到的是一个全新的礼物篮，内里的食品和饰品和你的礼物篮里的完全一样。但是，现在他们拥有的是独立于你的礼物篮的新的食品和饰品。
不知道上面的生存案例有没有使你更好的理解Java中的深浅拷贝，如果还是没有，那么直接往下看即可！

大致的了解了什么是Java中的深浅拷贝之后，那么我们又该如何使用代码去实现它们呢？

2.浅拷贝的实现

        在Java中，实现浅拷贝通常使用clone()方法。该方法会创建一个新对象，并将原始对象的全部字段值复制到新对象中。但是须要留意的是，对于引用范例的成员变量，仍然是浅拷贝，即复制的是引用而不是对象自己。

        下面是在Java中实现浅拷贝的详细步骤：
1.实现Cloneable接口：

1. class MyClass implements Cloneable {
2.     // 类的定义
3. }

复制代码

 2.重写clone()方法并调用super.clone()：

1. class MyClass implements Cloneable {
2.     // 类的定义
4.     @Override
5.     public Object clone() throws CloneNotSupportedException {
6.         return super.clone();
7.     }
8. }

复制代码

3.在使用时捕获CloneNotSupportedException异常：

1. try {
2.     MyClass copy = (MyClass) original.clone();
3. } catch (CloneNotSupportedException e) {
4.     e.printStackTrace();
5. }

复制代码

4.强制转换：由于clone()方法返回的是Object范例，因此在使用时须要进行范例转换。

1. try {
2.     MyClass copy = (MyClass) original.clone();
3. } catch (CloneNotSupportedException e) {
4.     e.printStackTrace();
5. }

复制代码

       
         这就是实现Java中浅拷贝的四步实现流程，信赖你仔细的读完上边的代码之后，对Java中浅拷贝的实现流程已经有了开端的理解了，现在让我们使用一个完备的案例，来实现一下Java中的浅拷贝：    

1. class Person implements Cloneable {
2.     private String name;
3.     private Address address;
5.     public Person(String name, Address address) {
6.         this.name = name;
7.         this.address = address;
8.     }
10.     // Getter and setter 方法
12.     @Override
13.     protected Object clone() throws CloneNotSupportedException {
14.         return super.clone();
15.     }
16. }
18. class Address {
19.     private String city;
20.    
21.     public Address(String city) {
22.         this.city = city;
23.     }
25.     // Getter and setter 方法
26. }
28. public class ShallowCopyExample {
29.     public static void main(String[] args) {
30.         Address address = new Address("New York");
31.         Person person1 = new Person("Alice", address);
33.         try {
34.             Person person2 = (Person) person1.clone();
35.             // 输出: true
36.             System.out.println(person1.getAddress() == person2.getAddress());
37.         } catch (CloneNotSupportedException e) {
38.             e.printStackTrace();
39.         }
40.     }
41. }

复制代码

以上代码演示了一个浅拷贝的例子。让我来解释一下它的执行过程和输出：
   

• 首先，我们定义了两个类：Person和Address。Person类有一个name属性和一个address属性，而Address类只有一个city属性。
  
• 在ShallowCopyExample类的main方法中，我们创建了一个Address对象，表示Alice的地址是"New York"。然后，我们创建了一个Person对象person1，传入了名字"Alice"和上面创建的Address对象。
  
• 接着，我们调用person1.clone()方法进行浅拷贝。由于Person类实现了Cloneable接口并重写了clone()方法，因此它支持克隆操纵。在clone()方法内部，我们调用了super.clone()来复制Person对象自己，但是对于address属性，只是复制了其引用，而没有对Address对象进行深度复制。
  
• 输出语句System.out.println(person1.getAddress() == person2.getAddress());比较了person1和person2的address属性是否是同一个对象。由于浅拷贝只是复制了引用，所以person1和person2的address属性指向的是同一个Address对象，因此输出结果为true。
  

  这样我们就大致的了解了在Java中如何去实现对象的浅拷贝了。

3.深拷贝的实现

        在Java中实现深拷贝相对于浅拷贝来说更为复杂，因为须要确保对象及其引用的全部对象都被复制到新的内存地址上。
        下面是在Java中实现深拷贝的详细流程：
1.实现Cloneable接口：同样，为了使用clone()方法，须要确保类实现了Cloneable接口。

1. class MyClass implements Cloneable {
2.     // 类的定义
3. }

复制代码

2.重写clone()方法：在重写的clone()方法中，除了调用super.clone()来复制对象自己之外，还须要递归地复制全部引用的对象。

1. class MyClass implements Cloneable {
2.     private AnotherClass anotherObject;
4.     public MyClass(AnotherClass anotherObject) {
5.         this.anotherObject = anotherObject;
6.     }
8.     // Getter and setter 方法
10.     @Override
11.     public Object clone() throws CloneNotSupportedException {
12.         MyClass clonedObject = (MyClass) super.clone();
13.         // 对引用类型的成员变量进行深度复制
14.         clonedObject.anotherObject = (AnotherClass) anotherObject.clone();
15.         return clonedObject;
16.     }
17. }

复制代码

3.在引用范例的类中同样实现深拷贝：如果类中有成员变量是引用范例，那么须要在该引用范例的类中同样实现深拷贝。

1. class AnotherClass implements Cloneable {
2.     // 类的定义
4.     @Override
5.     public Object clone() throws CloneNotSupportedException {
6.         return super.clone();
7.     }
8. }

复制代码

4.调用clone()方法：现在可以调用clone()方法来获取深拷贝的对象。

1. public class DeepCopyExample {
2.     public static void main(String[] args) {
3.         AnotherClass anotherObject = new AnotherClass();
4.         MyClass original = new MyClass(anotherObject);
5.         MyClass deepCopy = null;
7.         try {
8.             deepCopy = (MyClass) original.clone();
9.         } catch (CloneNotSupportedException e) {
10.             e.printStackTrace();
11.         }
12.     }
13. }

复制代码

        这就是实现Java中深拷贝的四步实现流程，当然，现在让我们使用一个完备的案例，来实现一下Java中的深拷贝：    

1. class Person implements Cloneable {
2.     private String name;
3.     private Address address;
5.     public Person(String name, Address address) {
6.         this.name = name;
7.         this.address = address;
8.     }
10.     // Getter and setter 方法
12.     @Override
13.     protected Object clone() throws CloneNotSupportedException {
14.         Person clonedPerson = (Person) super.clone();
15.         clonedPerson.address = (Address) this.address.clone();
16.         return clonedPerson;
17.     }
18. }
20. class Address implements Cloneable {
21.     private String city;
22.    
23.     public Address(String city) {
24.         this.city = city;
25.     }
27.     // Getter and setter 方法
29.     @Override
30.     protected Object clone() throws CloneNotSupportedException {
31.         return super.clone();
32.     }
33. }
35. public class DeepCopyExample {
36.     public static void main(String[] args) {
37.         Address address = new Address("New York");
38.         Person person1 = new Person("Alice", address);
40.         try {
41.             Person person2 = (Person) person1.clone();
42.             // 输出: false
43.             System.out.println(person1.getAddress() == person2.getAddress());
44.         } catch (CloneNotSupportedException e) {
45.             e.printStackTrace();
46.         }
47.     }
48. }

复制代码

让我解释一下代码的主要部分：
   

• Person 类和 Address 类都实现了 Cloneable 接口，这是为了表明它们可以被克隆。
  
• 在 Person 类中，有一个私有字段 address，范例为 Address。Person 类的构造函数用于初始化这个字段。
  
• Person 类的 clone() 方法首先调用了 super.clone()，这会复制 Person 对象自己。然后，它对 address 字段进行了深拷贝，即创建了一个新的 Address 对象，并将其赋值给 clonedPerson 的 address 字段。
  
• Address 类中的 clone() 方法也是调用了 super.clone()，实现了浅拷贝，因为 Address 类只有一个字段，且该字段为不可变范例。
  
• 在 main() 方法中，首先创建了一个 Address 对象和一个 Person 对象。然后，通过调用 clone() 方法，创建了一个新的 Person 对象 person2，其中包含了新的 Address 对象。
  
• 末了，通过比较 person1 和 person2 的地址字段，可以看到它们不相同，这表明在克隆过程中进行了深拷贝。
  

  这样我们就大致的了解了在Java中如何去实现对象的深拷贝了。

4.深浅拷贝的作用

        了解完了Java中的深浅拷贝之后，那么其有什么用呢？
浅拷贝的作用：

   

• 节流内存空间：浅拷贝只复制对象自己，不会复制对象引用的内容，因此在某些情况下可以节流内存空间。
  
• 进步对象创建速率：由于浅拷贝只复制对象自己，因此复制过程相对较快。
  
• 适用于不包含引用范例成员变量的对象：如果对象中的成员变量都是基本数据范例或者不须要被复制的对象，那么浅拷贝是一个简单有用的复制方式。
  

  深拷贝的作用：

   

• 确保对象的独立性：深拷贝会递归地复制对象及其引用的全部对象，从而确保复制后的对象与原始对象完全独立，对复制对象的修改不会影响原始对象。
  
• 数据安全性：在多线程环境下，深拷贝可以确保对象的数据安全性，因为每个线程都可以操纵独立的对象，而不会相互影响。
  
• 制止对象共享的副作用：在某些情况下，对象的共享大概会导致不测的副作用，深拷贝可以制止这种情况的发生，保证数据的一致性和可靠性。
  
• 适用于包含引用范例成员变量的对象：如果对象中包含了引用范例的成员变量，而且须要复制全部引用的对象，那么深拷贝是更合适的选择。
  

          总的来说，浅拷贝适用于简单对象的复制，可以进步性能和节流内存空间，而深拷贝则适用于须要确保对象独立性和数据安全性的情况，尤其是当对象包含引用范例成员变量时。

---

以上就是本篇文章的全部内容了~~~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。