Java中如何复制泛型集合？自定义List拷贝构造器引用传递问题

你遇到的核心问题是Java的对象引用传递特性：直接将l_node.item赋值给新节点的item，本质是让两个节点指向同一个对象实例，修改该对象的内部状态时，原集合和新集合会同时受影响。要生成值相同但引用独立的新节点，需根据泛型T的特性选择合适的拷贝方案，以下是几种可行实现：

方案1：让T实现Cloneable接口并重写clone方法 #

利用Java原生的Cloneable标记接口，为T类型实现对象拷贝逻辑。

修改ListNode构造器 #

public ListNode(T item, ListNode<T> next, ListNode<T> prev) throws CloneNotSupportedException {
    // 调用clone方法生成新实例，注意强制类型转换
    this.item = (T) item.clone();
    this.next = next;
    this.prev = prev;
}

为T类实现Cloneable #

自定义类需实现Cloneable并重写clone方法（需改为public权限），注意处理浅/深拷贝：

public class User implements Cloneable {
    private String name;
    private int age;
    private List<String> hobbies; // 可变引用字段

    @Override
    public User clone() throws CloneNotSupportedException {
        // 先调用父类完成浅拷贝
        User cloned = (User) super.clone();
        // 对可变引用字段手动做深拷贝，避免共享引用
        cloned.hobbies = new ArrayList<>(this.hobbies);
        return cloned;
    }
}

更新List拷贝构造器 #

处理CloneNotSupportedException异常：

public List(List<T> l) throws CloneNotSupportedException {
    this();
    _size = l._size;
    ListNode<T> l_node = l._head;
    ListNode<T> node = _head;
    while((l_node = l_node.next) != l._head) {
        node.next = new ListNode<>(l_node.item, _head, node);
        node = node.next;
    }
}

方案2：自定义拷贝接口（更优雅的类型约束） #

如果觉得Cloneable设计不够直观，可以自定义拷贝接口，强制T类型实现拷贝逻辑。

定义拷贝接口 #

public interface Copyable<T> {
    T copy();
}

让T实现接口 #

public class User implements Copyable<User> {
    private String name;
    private int age;

    @Override
    public User copy() {
        User newUser = new User();
        newUser.name = this.name;
        newUser.age = this.age;
        // 可变引用字段同样需手动拷贝
        return newUser;
    }
}

修改List泛型约束与拷贝构造器 #

// 约束T必须实现Copyable接口
public class List<T extends Copyable<T>> {
    // ... 原有代码 ...

    public List(List<T> l) {
        this();
        _size = l._size;
        ListNode<T> l_node = l._head;
        ListNode<T> node = _head;
        while((l_node = l_node.next) != l._head) {
            // 调用自定义copy方法生成新实例
            node.next = new ListNode<>(l_node.item.copy(), _head, node);
            node = node.next;
        }
    }

    static class ListNode<T> {
        T item;
        ListNode<T> next;
        ListNode<T> prev;

        public ListNode(T item, ListNode<T> next, ListNode<T> prev) {
            this.item = item;
            this.next = next;
            this.prev = prev;
        }
    }
}

方案3：传入自定义拷贝函数（最灵活） #

如果无法修改T类的源码（比如使用第三方类），可以在拷贝构造器中传入一个拷贝函数，由调用者决定拷贝逻辑。

修改List拷贝构造器 #

public List(List<T> l, Function<T, T> copyFunction) {
    this();
    _size = l._size;
    ListNode<T> l_node = l._head;
    ListNode<T> node = _head;
    while((l_node = l_node.next) != l._head) {
        // 利用传入的函数生成新实例
        T copiedItem = copyFunction.apply(l_node.item);
        node.next = new ListNode<>(copiedItem, _head, node);
        node = node.next;
    }
}

调用示例 #

List<User> originalList = new List<>();
// 添加元素...
// 调用时传入拷贝逻辑
List<User> copiedList = new List<>(originalList, item -> {
    User newUser = new User();
    newUser.setName(item.getName());
    newUser.setAge(item.getAge());
    newUser.setHobbies(new ArrayList<>(item.getHobbies()));
    return newUser;
});

特殊情况：不可变类型无需拷贝 #

如果T是Java内置的不可变类（如String、Integer、LocalDate、BigDecimal等），不需要做任何拷贝操作。这类类的实例状态一旦创建就无法修改，修改新集合元素本质是重新赋值新实例，不会影响原集合。

内容的提问来源于stack exchange，提问作者Mhwwhu