Java 中的 List 深拷贝：概念、方法与最佳实践

简介

在 Java 编程中，处理对象集合时，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是重要的概念。尤其是对于 List 这种常用的数据结构，理解如何进行深拷贝对于确保数据的完整性和避免意外的数据修改至关重要。本文将深入探讨 Java 中 List 深拷贝的相关知识，包括基础概念、使用方法、常见实践以及最佳实践。

目录

1. 深拷贝与浅拷贝基础概念
2. Java 中 List 深拷贝的使用方法
   • 使用序列化与反序列化
   • 手动递归复制
   • 使用第三方库（如 Apache Commons Collections）
3. 常见实践
   • 对象包含基本类型的 List 深拷贝
   • 对象包含复杂对象的 List 深拷贝
4. 最佳实践
   • 性能考量
   • 代码可读性与维护性
5. 小结
6. 参考资料

深拷贝与浅拷贝基础概念

• 浅拷贝：浅拷贝创建一个新对象，该对象有着原始对象属性值的一份精确拷贝。如果对象的属性是基本数据类型，拷贝的就是基本数据类型的值；如果属性是引用类型，拷贝的就是引用，而不是对象本身。这意味着原始对象和拷贝对象的引用类型属性指向同一个对象，对其中一个对象的引用类型属性进行修改会影响到另一个对象。
• 深拷贝：深拷贝不仅复制对象本身，还递归地复制对象所引用的所有对象。这样，原始对象和拷贝对象是完全独立的，对一个对象的修改不会影响到另一个对象。

Java 中 List 深拷贝的使用方法

使用序列化与反序列化

Java 的序列化机制可以用来实现深拷贝。通过将对象写入 ByteArrayOutputStream，再从 ByteArrayInputStream 中读取，从而创建一个完全独立的对象。

import java.io.*;
import java.util.ArrayList;
import java.util.List;

class DeepCopyableObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private int value;

    public DeepCopyableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }
}

public class DeepCopyListExample {
    public static <T extends Serializable> List<T> deepCopyList(List<T> list) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(list);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        @SuppressWarnings("unchecked")
        List<T> copiedList = (List<T>) ois.readObject();
        ois.close();

        return copiedList;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        List<DeepCopyableObject> originalList = new ArrayList<>();
        originalList.add(new DeepCopyableObject(1));
        originalList.add(new DeepCopyableObject(2));

        List<DeepCopyableObject> copiedList = deepCopyList(originalList);

        // 修改原始列表中的对象
        originalList.get(0).setValue(100);

        // 验证拷贝列表不受影响
        System.out.println("Original List: " + originalList.get(0).getValue());
        System.out.println("Copied List: " + copiedList.get(0).getValue());
    }
}

手动递归复制

手动递归复制每个元素，确保引用类型的对象也被深拷贝。

import java.util.ArrayList;
import java.util.List;

class DeepCopyableObject {
    private int value;

    public DeepCopyableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    // 复制构造函数用于深拷贝
    public DeepCopyableObject(DeepCopyableObject other) {
        this.value = other.value;
    }
}

public class ManualDeepCopyListExample {
    public static List<DeepCopyableObject> deepCopyList(List<DeepCopyableObject> list) {
        List<DeepCopyableObject> copiedList = new ArrayList<>();
        for (DeepCopyableObject obj : list) {
            copiedList.add(new DeepCopyableObject(obj));
        }
        return copiedList;
    }

    public static void main(String[] args) {
        List<DeepCopyableObject> originalList = new ArrayList<>();
        originalList.add(new DeepCopyableObject(1));
        originalList.add(new DeepCopyableObject(2));

        List<DeepCopyableObject> copiedList = deepCopyList(originalList);

        // 修改原始列表中的对象
        originalList.get(0).setValue(100);

        // 验证拷贝列表不受影响
        System.out.println("Original List: " + originalList.get(0).getValue());
        System.out.println("Copied List: " + copiedList.get(0).getValue());
    }
}

使用第三方库（如 Apache Commons Collections）

Apache Commons Collections 提供了方便的方法来进行深拷贝。

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.bag.HashBag;
import org.apache.commons.collections4.bag.SynchronizedBag;
import org.apache.commons.collections4.bag.UnmodifiableBag;
import org.apache.commons.collections4.collection.SynchronizedCollection;
import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.iterators.SynchronizedIterator;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
import org.apache.commons.collections4.map.SynchronizedMap;
import org.apache.commons.collections4.map.UnmodifiableMap;
import org.apache.commons.collections4.set.SynchronizedSet;
import org.apache.commons.collections4.set.UnmodifiableSet;
import org.apache.commons.collections4.transformer.ConstantTransformer;
import org.apache.commons.collections4.transformer.IdentityTransformer;
import org.apache.commons.collections4.transformer.TransformingTransformer;
import org.apache.commons.collections4.trie.PatriciaTrie;
import org.apache.commons.collections4.trie.SynchronizedPatriciaTrie;
import org.apache.commons.collections4.trie.UnmodifiablePatriciaTrie;

import java.util.ArrayList;
import java.util.List;

class DeepCopyableObject {
    private int value;

    public DeepCopyableObject(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    // 复制构造函数用于深拷贝
    public DeepCopyableObject(DeepCopyableObject other) {
        this.value = other.value;
    }
}

public class ApacheCommonsDeepCopyListExample {
    public static List<DeepCopyableObject> deepCopyList(List<DeepCopyableObject> list) {
        Transformer<DeepCopyableObject, DeepCopyableObject> transformer = new Transformer<DeepCopyableObject, DeepCopyableObject>() {
            @Override
            public DeepCopyableObject transform(DeepCopyableObject input) {
                return new DeepCopyableObject(input);
            }
        };
        return CollectionUtils.collect(list, transformer);
    }

    public static void main(String[] args) {
        List<DeepCopyableObject> originalList = new ArrayList<>();
        originalList.add(new DeepCopyableObject(1));
        originalList.add(new DeepCopyableObject(2));

        List<DeepCopyableObject> copiedList = deepCopyList(originalList);

        // 修改原始列表中的对象
        originalList.get(0).setValue(100);

        // 验证拷贝列表不受影响
        System.out.println("Original List: " + originalList.get(0).getValue());
        System.out.println("Copied List: " + copiedList.get(0).getValue());
    }
}

常见实践

对象包含基本类型的 List 深拷贝

当 List 中的对象只包含基本类型时，手动递归复制或使用第三方库都比较简单有效。上述手动递归复制和 Apache Commons Collections 的示例代码都适用于这种情况。

对象包含复杂对象的 List 深拷贝

如果 List 中的对象包含其他引用类型的属性，手动递归复制需要确保所有引用类型的属性也被正确深拷贝。使用序列化与反序列化则较为方便，因为它会自动处理对象图的递归复制，但要求所有对象都实现 Serializable 接口。

最佳实践

性能考量

• 序列化与反序列化：性能开销较大，因为涉及到将对象写入字节流和从字节流读取的操作。适用于对象结构复杂且需要确保完全独立的深拷贝场景。
• 手动递归复制：性能相对较好，尤其是对于简单对象结构。但代码复杂度较高，需要手动处理每个对象的复制逻辑。
• 第三方库：性能介于两者之间，具体取决于库的实现。优点是代码简洁，减少手动编写复制逻辑的工作量。

代码可读性与维护性

• 手动递归复制：代码可读性较差，尤其是对于复杂对象结构，维护成本较高。
• 序列化与反序列化：代码相对简洁，但要求对象实现 Serializable 接口，增加了一定的耦合度。
• 第三方库：使用第三方库可以提高代码的可读性和维护性，减少重复代码。但需要引入额外的依赖。

小结

在 Java 中进行 List 的深拷贝有多种方法，每种方法都有其优缺点。选择合适的方法取决于具体的应用场景，包括对象结构的复杂程度、性能要求以及代码的可读性和维护性。通过理解深拷贝和浅拷贝的概念，并掌握不同的实现方法，开发者能够更好地处理对象集合，确保数据的完整性和独立性。

参考资料

• Oracle Java 教程 - 序列化
• Apache Commons Collections 官方文档
• Effective Java, Second Edition - Joshua Bloch