脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java实现对象深克隆

Java中实现对象深克隆的四种方式

 更新时间：2025年10月29日 09:48:32   作者：qincloudshaw  
这篇文章主要介绍了如何在Java中实现对象的深克隆,可以通过手动实现clone()方法、使用序列化、第三方库Apache Commons Lang或Hutool等几种方式,每种方式都有其特点,需要的朋友可以参考下

在Java中实现对象的深克隆（Deep Clone）需要确保对象及其所有引用类型的字段都被复制，而不是共享相同的内存地址。以下是几种常见的实现方式：

方法1：手动实现深克隆

通过重写 clone() 方法并逐层复制引用对象：

@Data
@AllArgsConstructor
@NoArgsConstructor
class Address implements Cloneable {
    private String city;
    
    @Override
    protected Address clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Person implements Cloneable {
    private String name;
    private Address address;
    private List<String> hobbies;

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        // 深克隆引用对象
        cloned.address = this.address.clone();
        // 若hobbies是自定义对象列表，需逐个深克隆
        return cloned;
    }
}

public class DeepCloneExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address addr = new Address("Beijing");
        List<String> hobbies = List.of("reading", "swimming");
        Person p1 = new Person("Alice", addr, hobbies);
        
        // 深克隆
        Person p2 = p1.clone();
        
        // 修改克隆对象的属性，不会影响原对象
        p2.getAddress().setCity("Shanghai");
        p2.getHobbies().add("running");
        
        System.out.println(p1.getAddress().getCity()); // 输出: Beijing
        System.out.println(p2.getAddress().getCity()); // 输出: Shanghai
        System.out.println(p1.getHobbies()); // 输出: [reading, swimming]
        System.out.println(p2.getHobbies()); // 输出: [reading, swimming, running]
    }
}

关键点：

  1. 实现 Cloneable 接口：标记类支持克隆。
  2. 重写 clone() 方法：调用 super.clone() 后，手动复制引用类型字段。
  3. 逐层深克隆：对每个引用对象（如 Address）也需实现深克隆。

方法2：使用序列化 Serializable

通过序列化和反序列化实现深克隆：

@Data
@AllArgsConstructor
@NoArgsConstructor
class Address implements Serializable {
    private static final long serialVersionUID = 1L;
    private String city;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Address address;
    private List<String> hobbies;
    
    // 深克隆方法
    public Person deepClone() {
      // 序列化
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
          oos.writeObject(this);
      } catch (Exception e) {
          e.printStackTrace();
      }

      // 反序列化
      try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
          return (Person) ois.readObject();
      } catch (Exception e) {
          e.printStackTrace();
      }
        
    }
}

public class DeepCloneBySerialization {
    public static void main(String[] args) {
        Address addr = new Address("Beijing");
        List<String> hobbies = new ArrayList<>(List.of("reading", "swimming"));
        Person p1 = new Person("Alice", addr, hobbies);
        
        // 深克隆
        Person p2 = p1.deepClone();
        
        // 修改克隆对象的属性，不会影响原对象
        p2.getAddress().setCity("Shanghai");
        p2.getHobbies().add("running");
        
        System.out.println(p1.getAddress().getCity()); // 输出: Beijing
        System.out.println(p2.getAddress().getCity()); // 输出: Shanghai
        System.out.println(p1.getHobbies()); // 输出: [reading, swimming]
        System.out.println(p2.getHobbies()); // 输出: [reading, swimming, running]
    }
}

使用 ByteArrayOutputStream 将对象序列化为内存中的字节数组。 再通过 ByteArrayInputStream 从内存中读取该字节数组并反序列化成新对象。 整个过程不涉及任何磁盘 I/O，完全在内存中完成，效率更高。

import java.io.*;

public class DeepCloneUtil {
    public static <T extends Serializable> T deepClone(T object) {
        try (
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
        ) {
            // 序列化对象到内存中的字节数组
            oos.writeObject(object);

            try (
                ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bis);
            ) {
                // 反序列化并返回新对象
                return (T) ois.readObject();
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("深克隆失败", e);
        }
    }

    public static void main(String[] args) {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address, List.of("reading", "swimming"));

        // 深克隆
        Person person2 = DeepCloneUtil.deepClone(person1);

        // 修改克隆对象的属性，不会影响原对象
        person2.getAddress().setCity("Shanghai");

        System.out.println(person1.getAddress().getCity()); // 输出: Beijing
        System.out.println(person2.getAddress().getCity()); // 输出: Shanghai
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Address implements Serializable {
    private static final long serialVersionUID = 1L;
    private String city;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Address address;
    private List<String> hobbies;
}

关键点：

  1. 实现 Serializable 接口：所有类（包括嵌套类）必须可序列化。
  2. 通过流操作：将对象序列化为字节流，再反序列化为新对象，确保所有引用都被复制。
  3. 自动处理嵌套对象：无需手动逐层克隆

方法3：使用第三方库 Apache Commons Lang(推荐使用,因为一般项目中都会引入这个依赖)

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

使用 SerializationUtils.clone()：

import org.apache.commons.lang3.SerializationUtils;

// 确保所有类实现Serializable接口
class Address implements Serializable { /* ... */ }
class Person implements Serializable { /* ... */ }

public class DeepCloneWithLibrary {
    public static void main(String[] args) {
        // 创建对象
        Person p1 = new Person("Alice", new Address("Beijing"), List.of("reading"));
        
        // 深克隆
        Person p2 = SerializationUtils.clone(p1);
        
        // 修改克隆对象，不影响原对象
        p2.getAddress().setCity("Shanghai");
    }
}

方法4：使用第三方库 Hutool

使用 CloneUtil.cloneByStream(obj)：

需要对象及其嵌套对象实现 java.io.Serializable 接口

@Data
@AllArgsConstructor
@NoArgsConstructor
class Address implements java.io.Serializable {
  private String city;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class Person implements java.io.Serializable {
  private String name;
  private Address address;
}

public class HutoolDeepCloneExample {
  public static void main(String[] args) {
    Address addr = new Address("Beijing");
    Person p1 = new Person("Alice", addr);
    
    Person p2 = CloneUtil.cloneByStream(p1);
    
    p2.getAddress().setCity("Shanghai"); // 修改克隆对象的属性，不会影响原对象
    System.out.println(p1.getAddress().getCity()); // 输出: Beijing
    System.out.println(p2.getAddress().getCity()); // 输出: Shanghai
  }
}

到此这篇关于Java中实现对象深克隆的四种方式的文章就介绍到这了,更多相关Java实现对象深克隆内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Spring配置文件使用占位符配置方式

    Spring配置文件使用占位符配置方式

    这篇文章主要介绍了Spring配置文件使用占位符配置方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-11-11
  • java多线程volatile内存语义解析

    java多线程volatile内存语义解析

    这篇文章主要介绍了java多线程volatile内存语义解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-01-01
  • 详解Spring Boot的GenericApplicationContext使用教程

    详解Spring Boot的GenericApplicationContext使用教程

    这篇教程展示了如何在Spring应用程序中使用GenericApplicationContext 。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-11-11
  • java中for和forEach的速度比较实例Demo

    java中for和forEach的速度比较实例Demo

    for循环中的循环条件中的变量只求一次值,而foreach语句是java5新增,在遍历数组、集合的时候，foreach拥有不错的性能,这篇文章主要给大家介绍了关于java中for和forEach速度比较的相关资料,需要的朋友可以参考下
    2021-08-08
  • JDBC示例代码

    JDBC示例代码

    本教程提供了如何创建一个简单的JDBC应用程序的示例。演示如何打开一个数据库连接，执行SQL查询，并显示结果
    2014-03-03
  • 浅谈Java三目运算

    浅谈Java三目运算

    本文给大家主要介绍的是java中三目运算的详细介绍，并附上2个示例，希望对大家理解三目运算能够有所帮助。
    2015-03-03
  • 使用@RequestBody传对象参数时碰到的坑

    使用@RequestBody传对象参数时碰到的坑

    这篇文章主要介绍了使用@RequestBody传对象参数时碰到的坑，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-08-08
  • Java 中的 getDeclaredMethods() 方法(使用与原理)

    Java 中的 getDeclaredMethods() 方法(使用与原理)

    文章介绍了Java反射机制中的`getDeclaredMethods()`方法,详细讲解了其使用方法、原理、注意事项以及实际应用场景,帮助读者更好地理解和应用这一强大的工具,感兴趣的朋友一起看看吧
    2024-12-12
  • Springboot项目基于Devtools实现热部署步骤详解

    Springboot项目基于Devtools实现热部署步骤详解

    这篇文章主要介绍了Springboot项目基于Devtools实现热部署,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-06-06
  • mybatis整合ehcache做三级缓存的实现方法

    mybatis整合ehcache做三级缓存的实现方法

    ehcache是一个快速内存缓存框架,java项目里用起来很方便,下面这篇文章主要给大家介绍了关于mybatis整合ehcache做三级缓存的实现方法,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2023-06-06

最新评论