Java对象深拷贝：含LinkedList复合对象复制技巧

深度复制与浅层复制

在Java中复制对象时，理解深度复制（Deep Copy）和浅层复制（Shallow Copy）至关重要。

• 浅层复制：创建一个新对象，然后将原始对象的所有字段值复制到新对象中。如果字段是基本数据类型，则复制其值；如果字段是引用类型（如另一个对象或集合），则复制其引用。这意味着新旧对象将共享对同一内部对象的引用。当修改其中一个对象的内部引用对象时，另一个对象也会受到影响，这通常不是我们期望的结果。

  例如，对于一个Card对象：

  Card sourceCard = new Card(10, 0); // 10 of Hearts
  Card copyCard = sourceCard; // 浅层复制，copyCard和sourceCard指向同一个Card对象

  此时，sourceCard和copyCard是同一个Card对象的两个引用。如果修改sourceCard的属性，copyCard也会反映这些修改。

• 深度复制：不仅复制原始对象本身，还会递归地复制其内部所有引用类型的对象，直到所有嵌套对象都是独立的副本。这意味着复制后的对象及其所有内部对象与原始对象完全独立，修改其中一个不会影响另一个。这对于包含集合或其他自定义对象的复合对象尤为重要。

  实现深度复制通常需要为每个需要复制的类提供一个拷贝构造器或实现Cloneable接口并重写clone()方法。

实例变量的重要性

在Java中，如果一个类成员被声明为static，那么它属于类本身，而不是类的任何特定实例。这意味着所有该类的对象都共享同一个static成员。对于需要独立存储数据的对象（如Deck类中的m_cards列表），将其声明为static会导致所有Deck实例共享同一副牌，这显然不符合逻辑。

为了实现每个Deck对象拥有独立的牌组，m_cards必须是一个实例变量（非static）。

public class Deck {
    // 错误示例：static会导致所有Deck共享同一牌组
    // static LinkedList m_cards = new LinkedList();

    // 正确做法：m_cards是实例变量，每个Deck对象有自己的牌组
    private LinkedList m_cards;

    // ... 其他方法
}

通过将m_cards声明为实例变量，每个通过new Deck()创建的Deck对象都会拥有自己独立的m_cards列表。

实现深度复制：拷贝构造器模式

实现深度复制最常用且推荐的方式是使用拷贝构造器。这种方法清晰明了，且易于控制复制过程。

1. 为内部对象实现拷贝构造器 (Card类)

首先，我们需要确保Deck类中包含的Card对象可以被深度复制。这意味着Card类本身需要一个拷贝构造器。

public class Card {
    private int rank; // 牌面值，例如 2-14 (Ace)
    private int suit; // 花色，例如 0-3 (Hearts, Spades, Clubs, Diamonds)

    public Card(int rank, int suit) {
        this.rank = rank;
        this.suit = suit;
    }

    // 拷贝构造器：创建Card对象的深度副本
    public Card(Card sourceCard) {
        this.rank = sourceCard.rank;
        this.suit = sourceCard.suit;
    }

    // Getter 方法 (用于验证)
    public int getRank() { return rank; }
    public int getSuit() { return suit; }

    // Setter 方法 (用于演示深度复制效果，实际扑克牌可能不提供setter)
    public void setRank(int rank) { this.rank = rank; }
    public void setSuit(int suit) { this.suit = suit; }

    @Override
    public String toString() {
        String rankName;
        switch (rank) {
            case 11: rankName = "Jack"; break;
            case 12: rankName = "Queen"; break;
            case 13: rankName = "King"; break;
            case 14: rankName = "Ace"; break;
            default: rankName = String.valueOf(rank); break;
        }

        String suitName;
        switch (suit) {
            case 0: suitName = "Hearts"; break;
            case 1: suitName = "Spades"; break;
            case 2: suitName = "Clubs"; break;
            case 3: suitName = "Diamonds"; break;
            default: suitName = "Unknown"; break;
        }
        return rankName + " of " + suitName;
    }
}

2. 为外部容器对象实现拷贝构造器 (Deck类)

有了Card的拷贝构造器后，Deck的拷贝构造器就可以利用它来创建独立的Card对象副本。

import java.util.LinkedList;
import java.util.List; // 导入List接口用于subList方法

public class Deck {
    private LinkedList m_cards; // 声明为实例变量

    // 默认构造器：初始化一副全新的52张牌
    public Deck() {
        m_cards = new LinkedList<>(); // 为当前Deck实例初始化其自己的LinkedList
        for(int i = 0; i <= 3; i++) { // 遍历花色 (0-3)
            for (int j = 2; j <= 14; j++) { // 遍历牌面 (2-14, 14为Ace)
                m_cards.add(new Card(j, i)); // 创建新的Card对象并添加到列表中
            }
        }
    }

    // 拷贝构造器：实现Deck的深度复制
    public Deck(Deck sourceDeck) {
        // 1. 为新的Deck实例初始化其自己的LinkedList
        this.m_cards = new LinkedList<>();
        // 2. 遍历源Deck中的每张Card
        for(Card card : sourceDeck.m_cards) {
            // 3. 使用Card的拷贝构造器创建每张Card的独立副本，并添加到新Deck的列表中
            this.m_cards.add(new Card(card));
        }
    }

    // 获取牌组大小
    public int size() {
        return m_cards.size();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < m_cards.size(); i++) {
            sb.append(m_cards.get(i));
            if (i < m_cards.size() - 1) {
                sb.append(", ");
            }
        }
        sb.append(" (").append(size()).append(" total cards)");
        return sb.toString();
    }

    // 主方法：演示深度复制
    public static void main(String[] args) {
        System.out.println("--- 创建 Deck1 ---");
        Deck deck1 = new Deck();
        // 打印Deck1的前几张牌，以便观察
        List deck1SubList = deck1.m_cards.subList(0, Math.min(5, deck1.size()));
        System.out.println("Deck1 (前5张): " + deck1SubList);
        System.out.println("Deck1 总牌数: " + deck1.size());

        System.out.println("\n--- 创建 Deck2 (Deck1的深度复制) ---");
        Deck deck2 = new Deck(deck1);
        List deck2SubList = deck2.m_cards.subList(0, Math.min(5, deck2.size()));
        System.out.println("Deck2 (前5张): " + deck2SubList);
        System.out.println("Deck2 总牌数: " + deck2.size());

        System.out.println("\n--- 验证深度复制效果 ---");
        // 验证 Deck 实例是否独立
        System.out.println("Deck1 对象引用 (哈希码): " + System.identityHashCode(deck1));
        System.out.println("Deck2 对象引用 (哈希码): " + System.identityHashCode(deck2));
        System.out.println("Deck1 和 Deck2 是不同的 Deck 对象。");

        // 验证内部 LinkedList 是否独立
        System.out.println("Deck1 内部列表引用 (哈希码): " + System.identityHashCode(deck1.m_cards));
        System.out.println("Deck2 内部列表引用 (哈希码): " + System.identityHashCode(deck2.m_cards));
        System.out.println("Deck1 和 Deck2 内部的 LinkedList 也是不同的对象。");

        // 验证内部 Card 对象是否独立
        if (!deck1.m_cards.isEmpty()) {
            Card firstCardDeck1 = deck1.m_cards.get(0);
            Card firstCardDeck2 = deck2.m_cards.get(0);

            System.out.println("Deck1 第一张牌引用 (哈希码): " + System.identityHashCode(firstCardDeck1));
            System.out.println("Deck2 第一张牌引用 (哈希码): " + System.identityHashCode(firstCardDeck2));
            System.out.println("Deck1 和 Deck2 的第一张牌是不同的 Card 对象。");

            // 修改 Deck1 中的第一张牌，观察 Deck2 是否受影响
            System.out.println("\n修改 Deck1 中第一张牌的 Rank (从 " + firstCardDeck1.getRank() + " 改为 99)...");
            firstCardDeck1.setRank(99); // 假设 Card 类有 setRank 方法
            System.out.println("Deck1 第一张牌现在是: " + deck1.m_cards.get(0));
            System.out.println("Deck2 第一张牌仍然是: " + deck2.m_cards.get(0)); // 应该保持原始值

            if (firstCardDeck2.getRank() != 99) {
                System.out.println("验证成功：修改 Deck1 的卡牌不会影响 Deck2 的卡牌，实现了深度复制。");
            } else {