如何在第三个数组中复制三张卡片？

Question

扑克游戏中的练习：
我创建了一个包含 7 张卡片的初始对象数组。每张牌都由其价值（7、8、9、10、杰克...）和花色（梅花、菱形...）指定。
我创建了第二个数组来计算相同值的卡片的数量。例如，如果我有三张价值 7 的卡片，那么在我的第二张表中，价值 3 的整数将适合价值 7 的卡片。

我的问题：
在第三个数组Card[] cards = new Card[5] 中，如何将这 3 张价值为 7 的卡片复制到这张卡片的开头？我不是在寻找解决方案，而是在寻找一个想法。

第一个数组：

Card[] sevencards = new Card[7];

以下方法统计相同数值的牌张数：

private int[] nbCardsvalue(Card[] sevencards){
        int[] nbvalue = new int[13];
        for (int i = 0; i < sevencards).length; i++){
            if (sevencards[i].getValue() == 2){
                nbvalue [0]++;
            }else if (sevencards[i].getValue() == 3){
                nbvalue [1]++;
            }else if (sevencards[i].getValue() == 4){
                nbvalue [2]++;
            }else if (sevencards[i].getValue() == 5){
                nbvalue [3]++;
            }else if (sevencards[i].getValue() == 6){
                nbvalue [4]++;
            }else if (sevencards[i].getValue() == 7){
                nbvalue [5]++;
            }else if (sevencards[i].getValue() == 8){
                nbvalue [6]++;
            }else if (sevencards[i].getValue() == 9){
                nbvalue [7]++;
            }else if (sevencards[i].getValue() == 10){
                nbvalue [8]++;
            }else if (sevencards[i].getValue() == 11){
                nbvalue [9]++;  
            }else if (sevencards[i].getValue() == 12){
                nbvalue [10]++; 
            }else if (sevencards[i].getValue() == 13){
                nbvalue [11]++;
            }else if (sevencards[i].getValue() == 14){
                nbvalue [12]++;
            }else{
                return nbvalue ;
            }
        }
        return nbvalue ;
    }

澄清一下：

• 我的第一个数组包含 7 张扑克牌，
• 我的第二个数组计算相同值的卡片的数量，
• 第三个数组，大小为 5，包含我第一个数组中最好的五张牌或能够比较扑克游戏玩家手牌强度的最佳组合。

例如：
如果在我的第一个数组 Sevencards[] 中，我有 3 张价值为 7 的卡片（即三张卡片）。
在我的第二个数组 nbvalue[] 中，我将有 nbvalue[5] = 3，这表明我有 3 张价值为 7 的卡片。

我需要第三个数组（例如 Main[]），我将在其中放置我的组合，即三种。我在这个数组开头的三个 7。
我不知道如何获得这 3 张价值为 7 的卡片并将它们放入我的 Main[] 数组中。

这是我的班级卡片：

public class Card implements Comparable<Card>{
    private final Suit suit
    public final int Jack = 11;
    public final int Queen = 12;
    public final int King = 13;
    public final int Ace = 14;
    private final int value;

    public Card (Suit s, int v){
        this.suit = s;
        this.value = v;
    }
    public Couleur getSuit(){
        return suit
    }
    public int getValue(){
        return value;
    }
    public String toString(){
        String v = String.valueOf(value);
        String s = suit.toString();
        if (value >= 2 && value <= 10){
            return v + " de " + s;        
        }else if (value == 11){
            return "Jack of " + s;
        }else if (value == 12){
            return "Queen of " + s;
        }else if (value == 13){
            return "King of " + s;  
        }else if (value == 14){
            return "Ace of " + s;
        }
        return null;
    }
    public int compareTo(Card c2){
        if (this.value > c2.value){
            return 1;
        }else if (this.value < c2.value){
            return -1;
        }else {
            return 0;
        }
    }
}

Answer 1

您问“我如何将这 3 张价值为 7 的卡片复制到 [第三个数组] 的开头”，但您没有详细说明“复制”在您的逻辑方面的含义。更具体地说，在您的代码中（在您所描述的状态下），您有一个 Card 实例（我假设），它在调用 getValue() 时返回值 7，并且您有一个值为 3 的整数在特定位置（在索引 5 处）的另一个数组，它似乎表示该类型卡片的数量。

因此，在您的代码中复制 Card 的单个引用三 (3) 次，可能意味着只创建 Card 类的 3 个新实例（通过调用 Card 构造函数，即new Card(/* parameters */)，使用特定参数，所以创建的实例将表示值为 7 的卡片，即对 getValue() 的调用将为所有 3 个新创建的 Card 实例返回 7。 如果您使用 Card 类的代码更新您的帖子，我可以详细说明一下。现在我不知道你有哪些可用的构造函数，但如果需要，你总是可以添加更多 - 你可以添加一个特定的构造函数，有时称为“复制构造函数”，它会创建一个同类型卡片的新实例)。

当您创建 3 个 Card 实例中的每一个时，将它们分配给数组 cards 的所需索引处。

由于要创建（复制）并放入 cards 数组的卡片数量可能是动态的（有时可能少于或多于 3 个），因此您可以使用循环来完成此部分，并在循环内不断创建新的卡片实例并将它们分配给数组中的某个索引。 index 变量也是循环变量，从 0 开始，直到（不包括）您必须添加到 cards 数组开头的卡片数量。

但是，根据您的用例，您可能不必复制卡片并创建多个实例，您也可以只分配相同的引用，即 Card 实例您已经拥有（值 7 之一）到 cards 数组中的多个位置，而无需进行“复制”。这可以在逻辑上实现类似的结果（同样，免责声明，取决于您的用例）。

编辑：提供了 Card 类的代码。制作同种卡片的新实例（副本），会像这样

// The card reference I want to copy
Card someCard;
// This reference could be obtained in various ways, but one way would be from the sevencards array like this
someCard = sevencards[i];

// then we make 3 copies (we get 3 new references)
Card cardCopy1 = new Card(someCard.getSuit(), someCard.getValue());
Card cardCopy2 = new Card(someCard.getSuit(), someCard.getValue());
Card cardCopy3 = new Card(someCard.getSuit(), someCard.getValue());

// we assign the references to the other main/cards array, starting at the beginning, so at indices 0, 1 and 2
cards[0] = cardCopy1;
cards[1] = cardCopy2;
cards[2] = cardCopy3;

当然，这个示例代码总是复制 3 个副本，要复制任意数量的副本，必须将上面的代码更改为循环（for 循环或 while 循环，取决于您的喜好）。

编辑：这是使用一些辅助方法的方法

在您的 Card 类中添加一个 public Card clone() 方法（这不是必需的，但是由于您将 Suit 值作为 Couleur 类型返回并且构造函数只接受 Suit 类型，因此我们不能重用它无论如何构造函数）。

// Add this inside the Card class
public Card clone() {
    return new Card(suit, value);
}

然后在您的代码中创建 2 个新方法

    public Card findCardWithValue(int targetValue, Card[] array) {
        Card targetCard = null;
        for (Card card : array) {
            if (card.getValue() == targetValue) {
                targetCard = card;
            }
        }
        return targetCard;
    }

    public void copyCardIntoArray(Card card, int times, int startIndex, Card[] array) {
        while (times > 0 && startIndex < array.length) {
            // if you want to just reference to the same card instance you can just do this
            // array[startIndex] = card;
            // if you want to actually make new instances (copies / clones) then do this
            array[startIndex] = card.clone();

            startIndex += 1; // move the index 1 forward
            times -= 1; // reduce times by 1
        }
    }

然后在您的代码中，您在 e 上依次调用这两个方法并传递所需的参数值。并检查返回值是否为 null，以防数组不包含指定值的值。

        Card[] cards = new Card[5];

        int targetValue = 7;
        Card card = findCardWithValue(targetValue, sevencards);

        if (card != null) {
            // your nbvalue index is always 2 less than the card value
            int howManyTimesToCopy = nbvalue[card.getValue() - 2];
            copyCardIntoArray(card, howManyTimesToCopy, 0, cards);
        } else {
            // card with specified value was not found in the sevencards array
        }