什么是深拷贝

在Java中，对象的深拷贝是指创建一个新的对象，并复制原始对象的所有字段和属性，包括嵌套对象。深拷贝确保原始对象和拷贝对象是完全独立的，对其中一个对象的修改不会影响另一个对象。

深拷贝需要注意的点

在Java中，对象的深拷贝需要注意以下几点：

  1. 不可拷贝对象的状态，只能拷贝对象的状态描述。Java中对象的状态包括实例变量和内部类实例等。
  2. 对于可变对象，深拷贝后修改原始对象中的值也会修改拷贝对象中的值。因此，在进行深拷贝时需要创建新的对象，而不是直接引用原始对象。
  3. 对于不可变对象，深拷贝后修改原始对象中的值不会影响拷贝对象中的值。
  4. 对于数组和集合类对象，深拷贝时需要拷贝数组或集合中的每一个元素，而不仅仅是引用。
  5. 对于非内存中的对象，例如文件、网络资源等，深拷贝时需要重新创建资源而不是简单地引用。
  6. 对于非序列化的对象，深拷贝时需要通过实现Cloneable接口并重写clone()方法来实现。
  7. 对于实现了Serializable接口的对象，可以通过序列化和反序列化来实现深拷贝。但是需要注意，如果对象中有不可序列化的字段，则无法通过序列化实现深拷贝。

Java中对象的深拷贝需要注意不可拷贝对象的状态、创建新的对象、拷贝每个元素、重新创建资源以及实现Cloneable接口或实现Serializable接口等方法。需要根据具体情况选择合适的方法来实现深拷贝。

实现深拷贝的几种方式

要实现深拷贝，可以通过以下方式：

使用克隆方法：

Java中的clone()方法可以用于创建对象的深拷贝。为了使一个类可克隆，需要实现Cloneable接口并重写clone()方法。clone()方法默认使用浅拷贝，如果要进行深拷贝，需要在方法内部手动进行。


import java.lang.reflect.*;
import java.util.*;
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套对象的对象
        Person person = new Person("John", 25, new Address(123 Main St, "New York", "NY"));
        // 创建一个深拷贝对象
        Person deepCopy = DeepCopyExample.deepCopyUsingClone(person);
        // 修改原始对象的属性，并查看深拷贝对象的属性是否也发生了改变
        person.setName("Jane");
        person.setAge(30);
        person.getAddress().setStreet("456 Elm St");
        System.out.println("Original Person:");
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Address:");
        System.out.println(person.getAddress().getStreet());
        System.out.println("Deep Copy Person:");
        System.out.println("Name: " + deepCopy.getName());
        System.out.println("Age: " + deepCopy.getAge());
        System.out.println("Address:");
        System.out.println(deepCopy.getAddress().getStreet());
    }
    public static <T> T deepCopyUsingClone(T object) {
        try {
            T copy = object.getClass().newInstance();
            copy = (T) object.getClass().getMethod("clone").invoke(object);
            return copy;
        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
            return null;
        }
    }
}
class Person implements Cloneable, Serializable {
    private String name;
    private int age;
    private Address address;
     // 省略了构造方法和Getter和Setter方法
    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}
class Address implements Cloneable, Serializable {
    private String street;
    private String city;
    private String state;
    // Constructor, getters, and setters omitted for brevity
    @Override
    public Address clone() {
        try {
            return (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

在这个例子中，deepCopyUsingClone()方法使用Java反射机制来调用对象的clone()方法，从而创建对象的深拷贝。注意，这个例子仅仅适用于实现了Cloneable接口的对象。如果对象没有实现Cloneable接口，那么需要使用其他方法来实现深拷贝。同时，需要注意的是，如果对象的字段中有不可序列化的字段，那么使用克隆方法也无法实现深拷贝。

存在的问题
  • 实现深拷贝时需要在每个类中重写clone()方法，这会增加代码的复杂度和维护成本。
  • 如果类中有不可克隆的字段（例如静态字段或非原始类型字段），则无法使用clone()方法实现深拷贝。
  • 如果类中有循环引用，会导致无限递归，从而引发栈溢出异常。

使用反射实现

以下是一个使用Java反射实现深拷贝的示例代码：


import java.lang.reflect.*;
import java.util.*;
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套对象的对象
        Person person = new Person("John", 25, new Address(123 Main St, "New York", "NY"));
        // 创建一个深拷贝对象
        Person deepCopy = DeepCopyExample.deepCopyUsingReflection(person);
        // 修改原始对象的属性，并查看深拷贝对象的属性是否也发生了改变
        person.setName("Jane");
        person.setAge(30);
        person.getAddress().setStreet("456 Elm St");
        System.out.println("Original Person:");
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Address:");
        System.out.println(person.getAddress().getStreet());
        System.out.println("Deep Copy Person:");
        System.out.println("Name: " + deepCopy.getName());
        System.out.println("Age: " + deepCopy.getAge());
        System.out.println("Address:");
        System.out.println(deepCopy.getAddress().getStreet());
    }
    public static <T> T deepCopyUsingReflection(T object) {
        try {
            T copy = object.getClass().newInstance();
            Field[] fields = object.getClass().getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                if (field.get(object) instanceof Serializable) {
                    field.set(copy, field.get(object));
                } else {
                    field.set(copy, deepCopyUsingReflection(field.get(object)));
                }
            }
            return copy;
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
}
class Person implements Serializable {
    private String name;
    private int age;
    private Address address;
    // 省略了构造方法和Getter和Setter方法
}
class Address implements Serializable {
    private String street;
    private String city;
    private String state;
    // 省略了构造方法和Getter和Setter方法
}

在这个例子中，deepCopyUsingReflection()方法使用Java反射机制来获取对象的所有字段，并递归地深拷贝每个字段的值。如果字段的值是可序列化的，那么可以直接拷贝；如果字段的值是非序列化的，那么需要递归地调用该方法来进行深拷贝。注意，这个例子仅仅适用于没有非序列化字段的对象。如果对象中包含非序列化的字段，那么需要使用其他方法来实现深拷贝。

使用序列化：

另一种实现深拷贝的方法是通过将对象序列化到字节数组中，然后从字节数组重新创建对象。这种方法可以确保对象的完整深拷贝，包括嵌套对象。


import java.util.*;
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套对象的对象
        Person person = new Person("John", 25, new Address(123 Main St, "New York", "NY"));
        // 创建一个深拷贝对象
        Person deepCopy = DeepCopyExample.deepCopy(person);
        // 修改原始对象的属性，并查看深拷贝对象的属性是否也发生了改变
        person.setName("Jane");
        person.setAge(30);
        person.getAddress().setStreet("456 Elm St");
        System.out.println("Original Person:");
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Address:");
        System.out.println(person.getAddress().getStreet());
        System.out.println("Deep Copy Person:");
        System.out.println("Name: " + deepCopy.getName());
        System.out.println("Age: " + deepCopy.getAge());
        System.out.println("Address:");
        System.out.println(deepCopy.getAddress().getStreet());
    }
    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(object);
            oos.flush();
            oos.close();
            bos.close();
            byte[] byteArray = bos.toByteArray();
            ByteArrayInputStream bis = new ByteArrayInputStream(byteArray);
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}
class Person implements Serializable {
    private String name;
    private int age;
    private Address address;
    // 省略了构造方法和Getter和Setter方法
}
class Address implements Serializable {
    private String street;
    private String city;
    private String state;
    // 省略了构造方法和Getter和Setter方法
}

在这个例子中，Person和Address类都实现了Serializable接口，因此它们可以被序列化和反序列化来实现深拷贝。deepCopy()方法使用Java序列化和反序列化的机制来实现深拷贝。注意，这个例子仅仅适用于实现了Serializable接口的对象。如果对象中包含非序列化的字段，那么需要使用其他方法来实现深拷贝。

存在的问题
  • 序列化过程相对较慢，并且会增加对象的开销。
  • 序列化后，对象的类定义需要在序列化的字节数组中保持一致，否则会导致反序列化失败。
  • 如果对象中有不可序列化的字段（例如静态字段或非原始类型字段），则无法使用序列化实现深拷贝。

使用递归方法

以下是另一个实现深拷贝的示例代码，这次使用的是递归方法：

public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套对象的对象
        Person person = new Person("John", 25, new Address(123 Main St, "New York", "NY"));
        // 创建一个深拷贝对象
        Person deepCopy = deepCopyUsingRecursion(person);
        // 修改原始对象的属性，并查看深拷贝对象的属性是否也发生了改变
        person.setName("Jane");
        person.setAge(30);
        person.getAddress().setStreet("456 Elm St");
        System.out.println("Original Person:");
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Address:");
        System.out.println(person.getAddress().getStreet());
        System.out.println("Deep Copy Person:");
        System.out.println("Name: " + deepCopy.getName());
        System.out.println("Age: " + deepCopy.getAge());
        System.out.println("Address:");
        System.out.println(deepCopy.getAddress().getStreet());
    }
    public static Person deepCopyUsingRecursion(Person person) {
        if (person == null) {
            return null;
        }
        Person newPerson = new Person(person.getName(), person.getAge(), null); // 初始化新对象时，第三个参数暂时为null，等待后续处理
        if (person.getAddress() != null) { // 如果原始对象有地址，则递归拷贝地址对象
            newPerson.setAddress(deepCopyUsingRecursion(person.getAddress()));
        }
        return newPerson;
    }
}

使用第三方类库：Google Guava

以下是使用第三方类库Google Guava来实现深拷贝的示例代码：


import com.google.common.reflect.DeepCopy;
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套对象的对象
        Person person = new Person("John", 25, new Address(123 Main St, "New York", "NY"));
        // 使用Guava库实现深拷贝
        Person deepCopy = DeepCopy.copy(person);
        // 修改原始对象的属性，并查看深拷贝对象的属性是否也发生了改变
        person.setName("Jane");
        person.setAge(30);
        person.getAddress().setStreet("456 Elm St");
        System.out.println("Original Person:");
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Address:");
        System.out.println(person.getAddress().getStreet());
        System.out.println("Deep Copy Person:");
        System.out.println("Name: " + deepCopy.getName());
        System.out.println("Age: " + deepCopy.getAge());
        System.out.println("Address:");
        System.out.println(deepCopy.getAddress().getStreet());
    }
}

需要注意的是，使用第三方类库来实现深拷贝可能会增加代码的依赖性和复杂性。因此，在使用之前需要仔细评估其优缺点。

深拷贝存在的性能问题

  • 深拷贝比浅拷贝需要更多的内存和计算资源，因为它需要创建新的对象并复制原始对象的所有属性。
  • 对于大型对象或复杂对象图，深拷贝可能会变得非常慢，因为它需要复制大量的数据
  • 深拷贝可能会导致程序变得复杂和混乱，因为它需要在对象的各个部分之间建立新的连接。
  • 深拷贝可能会导致对象之间的循环引用，这会使对象无法被正确地释放，从而浪费内存。
  • 深拷贝需要实现Cloneable接口并重写clone()方法，这会增加代码的复杂度和维护成本。
  • 对于非序列化的对象，深拷贝可能无法正确地复制对象的所有属性，特别是对于非原始类型的属性。
  • 对于可变对象，深拷贝可能会导致对象的不一致性，因为修改原始对象也会修改拷贝的对象。

深拷贝的优化方案

  • 对于大型对象或复杂对象图，可以采用分块深拷贝或增量深拷贝的方法，以减少内存和计算资源的消耗。
  • 对于可变对象，可以采用不可变对象替代可变对象的方法，以避免修改原始对象时对拷贝对象的影响。
  • 对于非序列化的对象，可以采用其他方法实现深拷贝，例如使用反射或手动复制每个属性。
  • 对于对象的属性，可以采用浅拷贝的方法来减少内存和计算资源的消耗。
  • 可以使用缓存来避免重复创建相同对象的深拷贝，以减少计算资源的消耗。
  • 可以使用对象池或缓存来管理深拷贝后的对象，以避免内存泄漏和资源浪费。

综上所述，优化方案需要根据具体情况选择合适的方法来减少内存和计算资源的消耗，并避免出现不一致性和循环引用等问题。

在这里插入图片描述

最后

除了Java的深拷贝，还有其它的Java相关的知识，欢迎大家学习：

[玫瑰]Java基本数据类型的初始值
[玫瑰]Java中Deque接口方法解析
[玫瑰]List中set方法和add方法的区别

# java
Logo
AtomGit 开源协作平台测评赛

瓜分20万奖金 获得内推名额 丰厚实物奖励 易参与易上手

更多推荐

【Spring Boot 】Spring Boot + HikariCP 连接池使用示例

文章目录示例工具版本HikariCP 依赖HikariCP 配置1. connectionTimeout2. minimumIdle3. maximumPoolSize4. idleTimeout5. maxLifetime6. autoCommitSpring Boot Data + HikariCP + MySQL示例测试应用程序1. 使用 Maven 命令2. 使用 Eclipse3. 使用

avatar 开放原子开发者工作坊
cover

基于NSGAII的三目标优化算法

avatar 开放原子开发者工作坊
cover

教你python自动识别图文验证码的解决方案！

avatar 开放原子开发者工作坊