Java程序设计-洗牌器

Question

我正在尝试编写一个洗牌器，并且我知道我希望洗牌的方法。然而，我不知道最好的面向对象的编写方式。

该方法是一种相当常见的方法，如下所示：

• 为每个键分配一个随机数值，范围在 0 到 2,147,483,647 之间。
• 如果存在重复的键值（极不可能），则扔掉这副牌，然后重新开始。
• 将卡片存储在一个集合中，
• 按每个卡片的键值对集合进行排序

我的问题在于最好的 OOP 编写方式。首先，我想出了一个名为 Card 的对象，其中包含花色值、数字值和随机键值。然后我会有一个名为 Deck 的类，它扩展了 HashSet，我会将每张卡存储到 HashSet 中，然后按键值对其进行排序。我纠结的地方是，首先“生成”52 个 Card 对象的最有效方法是什么，以及如何对集合进行排序。我会实现接口“SortedSet”吗？如果是这样，我将如何编写比较器？

这是一个相当广泛的问题，更多地基于 OOP 设计实践，但我希望这是一个非常流畅且基于对象的解决方案。

干杯，

蒂姆。

编辑：

感谢大家的帮助。我的解决方案如下：

• 2 个枚举（CardValues、CardSuits），包含 4 个花色和 13 个可能的值
• Card 类，将 CardValue 和 CardSuit 作为构造函数参数。
• 扩展 TreeMap 的 Deck 类

当创建并洗牌新牌组时，我会循环遍历 CardSuit 枚举并创建 Cards，然后在该循​​环内，我遍历 CardValue 枚举。这将创建卡片，然后生成一个随机密钥并将它们放入 TreeMap 中。

由于总是有很小的机会出现按键重复，因此如果最终的牌组大小不是 52，我会抛出一个新的 InvalidDeckException。

感谢您的建议，我对这个解决方案感到非常满意。

Answer 1

使用TreeMap，为每张卡生成一个地图中不存在的随机数，并将其插入地图中作为卡的键，完成。

地图现在按生成的随机数排序。

另请参阅 http://en.wikipedia.org/wiki/Shuffling#Shuffling_algorithms

请注意这是一种延迟的随机播放方式，只需使用Collections.shuffle()即可。

Answer 2

我写了一些扑克分析的东西。我为所有卡类型创建了一个枚举，其中包含 rank 和 value 字段。然后我初始化了所有 52 个卡枚举的可能性。所以是的，我有 52 个枚举定义（以及一个单独的枚举，用于所有可能的 2 张牌起手牌——有时强力是最好的选择），

然后我创建了一个 Deck 类，其中有一个 Enum 类型列表。

初始化 Deck 就像生成 Enum 的 EnumSet 并将该集合传递给 List 一样简单。然后，您可以将 shuffle 方法放在 Deck 类上，并让它使用 Deck 的列表。

这样做的优点是您的应用程序中只有 52 张卡 - 就像 FlyWeight 模式。

Answer 3

我将卡定义为持有套件和数值的类。卡不应该知道任何相关的随机数。

Deck 是一个包含卡片列表并具有洗牌方法的类，使用可能不需要存储在某处的随机数。

Answer 4

Card.java:

import java.util.*;

public class Card {
    public enum Rank { DEUCE, THREE, FOUR, FIVE, SIX,
        SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE }

    public enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES }

    private final Rank rank;
    private final Suit suit;
    private Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public Rank rank() { return rank; }
    public Suit suit() { return suit; }
    public String toString() { return rank + " of " + suit; }

    private static final List<Card> protoDeck = new ArrayList<Card>();

    // Initialize prototype deck
    static {
        for (Suit suit : Suit.values())
            for (Rank rank : Rank.values())
                protoDeck.add(new Card(rank, suit));
    }

    public static ArrayList<Card> newDeck() {
        return new ArrayList<Card>(protoDeck); // Return copy of prototype deck
    }
}

Deal.java :

import java.util.*;

public class Deal {
    public static void main(String args[]) {
        int numHands = Integer.parseInt(args[0]);
        int cardsPerHand = Integer.parseInt(args[1]);
        List<Card> deck  = Card.newDeck();
        Collections.shuffle(deck);
        for (int i=0; i < numHands; i++)
            System.out.println(deal(deck, cardsPerHand));
    }

    public static ArrayList<Card> deal(List<Card> deck, int n) {
         int deckSize = deck.size();
         List<Card> handView = deck.subList(deckSize-n, deckSize);
         ArrayList<Card> hand = new ArrayList<Card>(handView);
         handView.clear();
         return hand;
     }
}

输出:

 $ java Deal 4 5
    [FOUR of HEARTS, NINE of DIAMONDS, QUEEN of SPADES, ACE of SPADES, NINE of SPADES]
    [DEUCE of HEARTS, EIGHT of SPADES, JACK of DIAMONDS, TEN of CLUBS, SEVEN of SPADES]
    [FIVE of HEARTS, FOUR of DIAMONDS, SIX of DIAMONDS, NINE of CLUBS, JACK of CLUBS]
    [SEVEN of HEARTS, SIX of CLUBS, DEUCE of DIAMONDS, THREE of SPADES, EIGHT of CLUBS]

参考:

• 枚举使用示例。

Answer 5

http://download .oracle.com/javase/6/docs/api/java/util/Collections.html#shuffle(java.util.List)

有关 java.util.Collections util 类中的 shuffle 方法，请参阅上述文档

 class Card {

private int number;
// other attributes

}

简单地 使用：-

Collections.shuffle(listOfCards);

Answer 6

最简单的事情就是为卡片类型分配一个值属性并对其进行排序（面卡 J、Q、K、A->11、12、13、14）。订购套装时，您必须选择一些任意顺序并组织成一个“包”卡片，其中包含一组已排序的每种套装。由于花色永远不会改变，因此包中总是有一组经过排序的梅花、红心、方块和黑桃。

生成卡片？每个包显然必须定义 4 套套装。拥有一个 CardFactory，根据给定的套装生成并返回每个套装的完整集合。工厂只是盲目地生成 2-10 和人头牌并返回排序后的集合。

Answer 7

您不应该进入不特定于给定卡的 Card 类数据。特别是，牌组内的顺序和随机数不是卡牌的属性（无论卡牌位于牌组的哪个位置，它都是相同的）。

卡属性应该只是其值和状态（显示/隐藏）。该牌组可以用列表来实现。洗牌只是 Deck 的一种方法。

对于洗牌有几种选择：

1）单独列出随机数并对其进行排序；随机数列表中的每个变化都会在卡列表中再现。问题是您不能使用 List() 已有的排序方法

2) 您添加一个包含 Card 和随机数的中间类（我们称之为 ShufCard），并且：

a) 牌组是一个列表这些中间对象。

b) 对于洗牌，您可以创建一个包含牌组内容的临时列表，洗牌，然后从临时列表中检索纸牌并保持其顺序。像这样的东西：

 List<ShufCard> list = new ArrayList<ShufCard>();
 for (Card card : Deck.cards) {
   list.add(new ShufCard(Card, Random.getNumber());
 }

 list.sort();
 Deck.cards.clear();

 for (ShufCard shCard : list) {
   Deck.cards.add(shCard.getCard());
 }