• Java中的深拷贝与浅拷贝

    目录

    一、浅拷贝

    二、深拷贝

    1、基本介绍  

     2、深拷贝的实现方式

    （1）嵌套clone方法

     （2）序列化方式

    三、总结

    一、浅拷贝

            浅拷贝由对象实现cloneable接口和重写clone方法，然后调用一次内部不做改写的clone方法克隆出一个对象，如果源对象内部存在引用类型的成员变量，那么就说该克隆是浅克隆，即对于引用类型属性，只克隆引用，两个对象的引用指向同一块内存地址，即同一个对象。

     示例代码：

    1. class Friend{
    2.     private String name;
    3.     private String home;
    4.  
    5.     public Friend(String name, String home) {
    6.         this.name = name;
    7.         this.home = home;
    8.     }
    9.  
    10.     public String getName() {
    11.         return name;
    12.     }
    13.  
    14.     public void setName(String name) {
    15.         this.name = name;
    16.     }
    17.  
    18.     public String getHome() {
    19.         return home;
    20.     }
    21.  
    22.     public void setHome(String home) {
    23.         this.home = home;
    24.     }
    25.  
    26.     @Override
    27.     public String toString() {
    28.         return "Friend{" +
    29.                 "name='" + name + '\'' +
    30.                 ", home='" + home + '\'' +
    31.                 '}';
    32.     }
    33. }
    34.  
    35. class Person implements Cloneable{
    36.     private String name;
    37.     private Integer age;
    38.     private Friend friend;
    39.  
    40.     public Person(String name, Integer age) {
    41.         this.name = name;
    42.         this.age = age;
    43.     }
    44.  
    45.     public String getName() {
    46.         return name;
    47.     }
    48.  
    49.     public void setName(String name) {
    50.         this.name = name;
    51.     }
    52.  
    53.     public Integer getAge() {
    54.         return age;
    55.     }
    56.  
    57.     public void setAge(Integer age) {
    58.         this.age = age;
    59.     }
    60.  
    61.     public Friend getFriend() {
    62.         return friend;
    63.     }
    64.  
    65.     public void setFriend(Friend friend) {
    66.         this.friend = friend;
    67.     }
    68.  
    69.     @Override
    70.     protected Object clone() throws CloneNotSupportedException {
    71.         return super.clone();
    72.     }
    73.  
    74.     @Override
    75.     public String toString() {
    76.         return "Person{" +
    77.                 "name='" + name + '\'' +
    78.                 ", age=" + age +
    79.                 ", friend=" + friend +
    80.                 '}';
    81.     }
    82. }
    83.  
    84. public class BaseOnClone {
    85.     public static void main(String[] args) throws CloneNotSupportedException {
    86.         Person person1 = new Person("张三", 18);
    87.         person1.setFriend(new Friend("f1", "西安"));
    88.         System.out.println("初始化的person：");
    89.         System.out.println(person1);
    90.         Person clonePerson = (Person) person1.clone();
    91.         System.out.println("克隆出来的person：");
    92.         System.out.println(clonePerson);
    93.         clonePerson.setName("tom");
    94.         clonePerson.setAge(20);
    95.         clonePerson.getFriend().setHome("延安");
    96.         System.out.println("修改克隆出来的person：");
    97.         System.out.println(clonePerson);
    98.         System.out.println("修改克隆出来的person之后，原来的person：");
    99.         System.out.println(person1);
    100.     }
    101. }

            执行结果如下：

             从执行结果来看，对于克隆之后的clonePerson对象，当修改了它的age属性的值时，clonePerson的age的变化并不会影响到person1的age属性；当修改clonePerson对象的friend属性的home值时，person1也受到了影响。

            这是因为通过浅拷贝复制对象时仅仅只是复制对象本身，包括基本属性，但该对象的属性引用其他对象时，该引用对象不会被复制，其拷贝出来的对象和原对象中属性引用的对象是同一个。因此可以使用深拷贝达到完全复制的目的，使得原对象和拷贝出来的对象之间互不影响。

    二、深拷贝

    1、基本介绍  

            进行深拷贝时，基本数据类型变量和引用类型变量指向的对象都会被复制，即针对引用类型的成员变量真正的复制一份，重新开辟空间保存，这样两个引用类型属性互不影响。

     2、深拷贝的实现方式

    （1）嵌套clone方法

            该方法给引用数据类型的属性也实现Cloneable接口，然后重写clone方法。以上面的浅拷贝例子为例：只需要在Friend中也实现Cloneable接口，然后重写clone()方法，再对Person中的clone()方法进行修改即可。

    1）在Friend中也实现Cloneable接口，然后重写clone()方法

    1. class Friend implements Cloneable{
    2.     private String name;
    3.     private String home;
    4.  
    5.     public Friend(String name, String home) {
    6.         this.name = name;
    7.         this.home = home;
    8.     }
    9.  
    10.     public String getName() {
    11.         return name;
    12.     }
    13.  
    14.     public void setName(String name) {
    15.         this.name = name;
    16.     }
    17.  
    18.     public String getHome() {
    19.         return home;
    20.     }
    21.  
    22.     public void setHome(String home) {
    23.         this.home = home;
    24.     }
    25.  
    26.     @Override
    27.     protected Object clone() throws CloneNotSupportedException {
    28.         return super.clone();
    29.     }
    30.  
    31.     @Override
    32.     public String toString() {
    33.         return "Friend{" +
    34.                 "name='" + name + '\'' +
    35.                 ", home='" + home + '\'' +
    36.                 '}';
    37.     }
    38. }

    2） 对Person中的clone()方法进行修改

    1. class Person implements Cloneable{
    2.     private String name;
    3.     private Integer age;
    4.     private Friend friend;
    5.  
    6.     public Person(String name, Integer age) {
    7.         this.name = name;
    8.         this.age = age;
    9.     }
    10.  
    11.     public String getName() {
    12.         return name;
    13.     }
    14.  
    15.     public void setName(String name) {
    16.         this.name = name;
    17.     }
    18.  
    19.     public Integer getAge() {
    20.         return age;
    21.     }
    22.  
    23.     public void setAge(Integer age) {
    24.         this.age = age;
    25.     }
    26.  
    27.     public Friend getFriend() {
    28.         return friend;
    29.     }
    30.  
    31.     public void setFriend(Friend friend) {
    32.         this.friend = friend;
    33.     }
    34.  
    35.     @Override
    36.     protected Object clone() throws CloneNotSupportedException {
    37.         Person person = (Person) super.clone();
    38.         person.friend = (Friend) friend.clone();
    39.         return person;
    40.     }
    41.  
    42.     @Override
    43.     public String toString() {
    44.         return "Person{" +
    45.                 "name='" + name + '\'' +
    46.                 ", age=" + age +
    47.                 ", friend=" + friend +
    48.                 '}';
    49.     }
    50. }

    3）完整代码

    1. class Friend implements Cloneable{
    2.     private String name;
    3.     private String home;
    4.  
    5.     public Friend(String name, String home) {
    6.         this.name = name;
    7.         this.home = home;
    8.     }
    9.  
    10.     public String getName() {
    11.         return name;
    12.     }
    13.  
    14.     public void setName(String name) {
    15.         this.name = name;
    16.     }
    17.  
    18.     public String getHome() {
    19.         return home;
    20.     }
    21.  
    22.     public void setHome(String home) {
    23.         this.home = home;
    24.     }
    25.  
    26.     @Override
    27.     protected Object clone() throws CloneNotSupportedException {
    28.         return super.clone();
    29.     }
    30.  
    31.     @Override
    32.     public String toString() {
    33.         return "Friend{" +
    34.                 "name='" + name + '\'' +
    35.                 ", home='" + home + '\'' +
    36.                 '}';
    37.     }
    38. }
    39.  
    40. class Person implements Cloneable{
    41.     private String name;
    42.     private Integer age;
    43.     private Friend friend;
    44.  
    45.     public Person(String name, Integer age) {
    46.         this.name = name;
    47.         this.age = age;
    48.     }
    49.  
    50.     public String getName() {
    51.         return name;
    52.     }
    53.  
    54.     public void setName(String name) {
    55.         this.name = name;
    56.     }
    57.  
    58.     public Integer getAge() {
    59.         return age;
    60.     }
    61.  
    62.     public void setAge(Integer age) {
    63.         this.age = age;
    64.     }
    65.  
    66.     public Friend getFriend() {
    67.         return friend;
    68.     }
    69.  
    70.     public void setFriend(Friend friend) {
    71.         this.friend = friend;
    72.     }
    73.  
    74.     @Override
    75.     protected Object clone() throws CloneNotSupportedException {
    76.         Person person = (Person) super.clone();
    77.         person.friend = (Friend) friend.clone();
    78.         return person;
    79.     }
    80.  
    81.     @Override
    82.     public String toString() {
    83.         return "Person{" +
    84.                 "name='" + name + '\'' +
    85.                 ", age=" + age +
    86.                 ", friend=" + friend +
    87.                 '}';
    88.     }
    89. }
    90.  
    91. public class BaseOnClone {
    92.     public static void main(String[] args) throws CloneNotSupportedException {
    93.         Person person1 = new Person("张三", 18);
    94.         person1.setFriend(new Friend("f1", "西安"));
    95.         System.out.println("初始化的person：");
    96.         System.out.println(person1);
    97.         Person clonePerson = (Person) person1.clone();
    98.         System.out.println("克隆出来的person：");
    99.         System.out.println(clonePerson);
    100.         clonePerson.setName("tom");
    101.         clonePerson.setAge(20);
    102.         clonePerson.getFriend().setHome("延安");
    103.         System.out.println("修改克隆出来的person：");
    104.         System.out.println(clonePerson);
    105.         System.out.println("修改克隆出来的person之后，原来的person：");
    106.         System.out.println(person1);
    107.     }
    108. }

             执行结果如下：

           

             从执行结果来看，在进行深拷贝的时候，无论是对基本数据类型 (age) 还是引用数据类型 (Friend) 进行修改，原对象 (Person) 都不会受到影响。 

     （2）序列化方式

            如果当类中的属性存在数组（数组不能实现Cloneable接口）或者属性之间的关系比较复杂时，上面的方法都不能很好的实现深克隆了。序列化的方式是让每个类都实现Serializable接口，然后通过序列化和反序列化操作达到深克隆的目的。步骤如下：

    • 使要序列化的对象和该对象的引用类型成员变量对象的类都实现Serializable接口，
    • 创建一个ByteArrayOutputStream内存数组输出流，创建一个ObjectOutputStream序列化流，并传入内存数组输出流，使用序列化流的writeobject方法将要序列化的对象写入内部数组中
    • 创建一个ByteArrayInputStream内存数组读取流，传入一个读取数据的数组，这个数组通过内存数组输出流的toByteArray方法获得，这个数组里面的数据其实就是已经被序列化成二进制数据的对象。
    • 最后创建一个ObjectInputStream反序列化流，并传入内存数组读取流，使用反序列化流的readobject方法将数组中的对象的信息反序列化出来。由于反序列化出的对象就是一个新的对象，完成了深克隆。

            注意：序列化时通过定义一个private static final long serialVersionUID固定要被序列化对象的版本号，且静态的成员和transient关键字修饰的成员不能被序列化。

            代码如下：

    1.  
    2.  
    3. import java.io.*;
    4.  
    5. class Friend implements Serializable {
    6.     private String name;
    7.     private String home;
    8.  
    9.     public Friend(String name, String home) {
    10.         this.name = name;
    11.         this.home = home;
    12.     }
    13.  
    14.     public String getName() {
    15.         return name;
    16.     }
    17.  
    18.     public void setName(String name) {
    19.         this.name = name;
    20.     }
    21.  
    22.     public String getHome() {
    23.         return home;
    24.     }
    25.  
    26.     public void setHome(String home) {
    27.         this.home = home;
    28.     }
    29.  
    30.     @Override
    31.     public String toString() {
    32.         return "Friend{" +
    33.                 "name='" + name + '\'' +
    34.                 ", home='" + home + '\'' +
    35.                 '}';
    36.     }
    37. }
    38.  
    39. class Person implements Serializable{
    40.     private String name;
    41.     private Integer age;
    42.     private Friend friend;
    43.  
    44.     public Person(String name, Integer age) {
    45.         this.name = name;
    46.         this.age = age;
    47.     }
    48.  
    49.     public String getName() {
    50.         return name;
    51.     }
    52.  
    53.     public void setName(String name) {
    54.         this.name = name;
    55.     }
    56.  
    57.     public Integer getAge() {
    58.         return age;
    59.     }
    60.  
    61.     public void setAge(Integer age) {
    62.         this.age = age;
    63.     }
    64.  
    65.     public Friend getFriend() {
    66.         return friend;
    67.     }
    68.  
    69.     public void setFriend(Friend friend) {
    70.         this.friend = friend;
    71.     }
    72.  
    73.     @Override
    74.     public String toString() {
    75.         return "Person{" +
    76.                 "name='" + name + '\'' +
    77.                 ", age=" + age +
    78.                 ", friend=" + friend +
    79.                 '}';
    80.     }
    81. }
    82.  
    83. public class BaseOnClone {
    84.     public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
    85.         Person person = new Person("张三", 18);
    86.         person.setFriend(new Friend("f1", "西安"));
    87.         System.out.println("初始化的person：");
    88.         System.out.println(person);
    89.  
    90.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
    91.         ObjectOutputStream oos = new ObjectOutputStream(bos);
    92.         oos.writeObject(person);
    93.  
    94.         ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    95.         ObjectInputStream ois = new ObjectInputStream(bis);
    96.         Person clonePerson = (Person) ois.readObject();
    97.  
    98.         System.out.println("克隆出来的person：");
    99.         System.out.println(clonePerson);
    100.         clonePerson.setName("tom");
    101.         clonePerson.setAge(24);
    102.         clonePerson.getFriend().setHome("长春");
    103.         System.out.println("修改克隆出来的person：");
    104.         System.out.println(clonePerson);
    105.         System.out.println("修改克隆出来的person之后，原来的person：");
    106.         System.out.println(person);
    107.     }
    108. }

            执行结果如下：

             

            从执行结果来看，序列化的方式也实现了深拷贝。在使用序列化实现深拷贝时，将对象进行序列化之后写入流中，然后通过反序列化读取流，生成新对象，而新生成的对象和原对象之间互不影响。

    三、总结

            对于浅拷贝而言，在复制对象时仅仅复制对象本身，包括基本属性和引用类型，拷贝出来的对象和原对象中属性所引用的对象是同一个。

            对于深拷贝而言，复制之后的对象和原对象之间互不影响。

  • 相关阅读:
    Java调用Web Service接口
    ChatGPT将引发网络安全三大革命
    模块化与单片化优缺点解析：为什么单片链仍是 DeFi 协议的最好选择？
    阿里版ChatGPT：通义千问pk文心一言
    GBase 8s是否带集群模块并实现负载均衡
    三极管原理介绍
    【win 10】Chrome 添加YouTube™ 双字幕插件
    企业工程项目管理系统源码（三控：进度组织、质量安全、预算资金成本、二平台：招采、设计管理）
    Netty简介及简单客户端/服务端示例代码
    [NOI2019]斗主地
  • 原文地址：https://blog.csdn.net/weixin_47382783/article/details/126398991