深拷贝是指在复制对象时，不仅复制对象本身和其内部的基本数据类型字段，还递归地复制对象内部所有引用类型字段所引用的对象，从而创建全新的对象结构。深拷贝可以保证复制后的对象与原对象完全独立，对复制对象的修改不会影响原对象，反之亦然。这意味着原始对象和深拷贝对象将拥有独立的内存地址，对深拷贝对象所做的更改不会影响原始对象。深拷贝通常适用于包含复杂内部结构的对象（如包含嵌套对象的类）。

使用上面的例子，如果对对象 B 进行深拷贝，修改对象 B 内部引用类型字段所指向的对象不会影响对象 A 内部相应的字段所引用的对象，因为它们引用的是两个不同的对象。

以下是一个简单的示例代码来演示浅拷贝和深拷贝的区别：


import java.util.ArrayList;
import java.util.List;
 
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个原始的 List 对象，包含三个字符串元素
        List<String> originalList = new ArrayList<>();
        originalList.add("元素 1");
        originalList.add("元素 2");
        originalList.add("元素 3");
 
        // 执行浅拷贝
        List<String> shallowCopy = shallowCopy(originalList);
 
        // 执行深拷贝
        List<String> deepCopy = deepCopy(originalList);
 
        // 更改原始列表中的元素
        originalList.set(0, "新元素 1");
 
        // 打印原始列表、浅拷贝列表和深拷贝列表的内容
        System.out.println("原始列表：" + originalList);
        System.out.println("浅拷贝列表：" + shallowCopy);
        System.out.println("深拷贝列表：" + deepCopy);
    }
 
    // 执行浅拷贝的方法
    public static <T> List<T> shallowCopy(List<T> listToCopy) {
        List<T> newList = new ArrayList<>();
        for (T item : listToCopy) {
            newList.add(item);
        }
        return newList;
    }
 
    // 执行深拷贝的方法
    public static <T> List<T> deepCopy(List<T> listToCopy) {
        List<T> newList = new ArrayList<>();
        for (T item : listToCopy) {
            // 如果元素是一个复杂对象，需要递归执行深拷贝
            if (item instanceof Cloneable) {
                try {
                    T clonedItem = (T) item.getClass().getMethod("clone").invoke(item);
                    newList.add(clonedItem);
                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();
                }
            } else {
                // 如果元素是一个基本类型或不可拷贝的对象，直接添加到新列表中
                newList.add(item);
            }
        }
        return newList;
    }
}

在这个示例中，我们创建了一个包含三个字符串元素的List对象originalList。然后，我们执行了浅拷贝和深拷贝操作，分别将originalList复制到shallowCopy和deepCopy变量中。接着，我们更改了原始列表中的第一个元素，并打印出原始列表、浅拷贝列表和深拷贝列表的内容。

可以看到，浅拷贝列表和原始列表共享相同的内存地址，因此对原始列表的更改也会反映在浅拷贝列表中。而深拷贝列表则拥有独立的内存地址，对原始列表的更改不会影响深拷贝列表。

请注意，深拷贝对于包含复杂内部结构的对象（如包含嵌套对象的类）可能会比较复杂，因为需要递归地执行拷贝操作。此外，如果对象的类没有实现Cloneable接口，或者其clone()方法被覆盖并且没有正确实现拷贝逻辑，那么深拷贝可能无法正常工作。在这种情况下，你可能需要手动实现拷贝逻辑，或者使用其他方法来复制对象。

二、Java中使用工具来帮助进行对象的拷贝

以下是一些常见的工具和方法：

1. clone()方法：Cloneable接口中的clone()方法可以用来拷贝对象。如果一个类实现了Cloneable接口并正确重写了clone()方法，那么可以使用clone()方法来创建对象的副本。示例如下：


public class MyClass implements Cloneable {
    // 定义字段
    private int field;
 
    // 构造函数
    public MyClass(int field) {
        this.field = field;
    }
 
    @Override
    public Object clone() {
        try {
            MyClass clonedObject = (MyClass) super.clone();
            return clonedObject;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
 
    public static void main(String[] args) {
        MyClass obj1 = new MyClass(10);
        MyClass obj2 = obj1.clone();
 
        System.out.println(obj1 == obj2);  // false，输出为 false 表示 obj1 和 obj2 是不同的对象
 
        System.out.println(obj1.field == obj2.field);  // true，输出为 true 表示 obj1 和 obj2 的 field 字段值相同
    }
}

上述示例中，MyClass类实现了Cloneable接口，并正确重写了clone()方法。通过调用clone()方法，可以创建MyClass对象的副本。

2. ObjectInputStream和ObjectOutputStream类：这些类位于java.io包中，可以用于将对象序列化到流中，然后再从流中反序列化回对象。示例如下：


import java.io.*;
 
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建一个原始的 MyClass 对象
        MyClass obj1 = new MyClass(10);
 
        // 将 obj1 对象序列化到流中
        try (ObjectOutputStream objOutputStream = new ObjectOutputStream(new FileOutputStream("object.ser"))) {
            objOutputStream.writeObject(obj1);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // 从流中反序列化回对象
        try (ObjectInputStream objInputStream = new ObjectInputStream(new FileInputStream("object.ser"))) {
            MyClass obj2 = (MyClass) objInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
 
        System.out.println(obj1 == obj2);  // false，输出为 false 表示 obj1 和 obj2 是不同的对象
 
        System.out.println(obj1.field == obj2.field);  // true，输出为 true 表示 obj1 和 obj2 的 field 字段值相同
    }
}
 
class MyClass implements Serializable {
    // 定义字段
    private int field;
 
    // 构造函数
    public MyClass(int field) {
        this.field = field;
    }
}

上述示例中，MyClass类实现了Serializable接口。通过使用ObjectOutputStream和ObjectInputStream，可以将MyClass对象序列化到文件中，然后再从文件中反序列化回对象。这也实现了对象的拷贝。

需要注意的是，对象的拷贝涉及到对象的状态和内容的复制。在进行拷贝时，需要确保拷贝的对象具有相同的状态和内容。以上介绍的方法适用于大部分情况下的对象拷贝，但在某些特殊情况下，可能需要根据具体需求进行更复杂的拷贝操作。

⭐三、bean工具类

在开发中可以自己封装一个通用的工具方法，用于将一个对象的属性复制到另一个对象中。以下参考b站up主三更草堂博客项目中封装的工具类，如下：


public class BeanCopyUtils {
    private BeanCopyUtils() {
    }
 
    public static <V> V copyBean(Object source, Class<V> clazz) {
        //创建目标对象
        V result = null;
        try {
            result = clazz.newInstance();
            //实现属性copy
            copyProperties(source, result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回结果
        return result;
    }
 
    public static <O, V> List<V> copyBeanList(List<O> list, Class<V> clazz) {
        return list.stream()
                .map(o -> copyBean(o, clazz))
                .collect(Collectors.toList());
    }
}

其中包含两个方法：

copyBean 方法接收一个源对象和目标对象的类作为参数，通过反射创建目标对象，并将源对象的属性复制到目标对象中。
copyBeanList 方法接收一个源对象列表和目标对象的类作为参数，使用 Java 8 的 Stream API 对列表中的每个对象调用 copyBean 方法，最终返回复制后的对象列表。

这种方式可以减少重复的属性复制代码，提高代码的复用性和可维护性。需要注意的是，该方法在处理属性复制时使用的是浅拷贝，如果需要深拷贝属性，可能需要额外的处理。

总结

浅拷贝只复制对象本身和基本数据类型字段，引用类型字段仍然指向相同的对象。
深拷贝除了复制对象本身和基本数据类型字段外，还递归复制所有引用类型字段所引用的对象，创建全新的对象结构。

浅拷贝只复制对象的引用,而深拷贝则递归复制了所有的值。选择使用哪种方式需要根据具体的需求,浅拷贝更高效但有引用相同的风险,深拷贝对于防止修改原对象很有用,但是相对来说更慢且更耗费内存。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/269106?site