1

我正在尝试编写一种方法来从甲板顶部移除指定数量的卡片并将它们作为数组返回。

这就是我到目前为止所做的。创建牌组的方法，复制牌组，返回数组中指定位置的牌的方法，返回牌组大小的方法，洗牌和切牌（不确定这些是正确的）。这是卡片类

public class Card {

    private final int suit; // 0, 1, 2, 3 represent Spades, Hearts, Clubs,
                            // Diamonds, respectively

    private final int value; // 1 through 13 (1 is Ace, 11 is jack, 12 is
                                // queen, 13 is king)

    /*
     * Strings for use in toString method and also for identifying card images
     */
    private final static String[] suitNames = { "s", "h", "c", "d" };
    private final static String[] valueNames = { "Unused", "A", "2", "3", "4",
            "5", "6", "7", "8", "9", "10", "J", "Q", "K" };

    /**
     * Standard constructor.
     * 
     * @param value
     *            1 through 13; 1 represents Ace, 2 through 10 for numerical
     *            cards, 11 is Jack, 12 is Queen, 13 is King
     * @param suit
     *            0 through 3; represents Spades, Hearts, Clubs, or Diamonds
     */
    public Card(int value, int suit) {
        if (value < 1 || value > 13) {
            throw new RuntimeException("Illegal card value attempted.  The "
                    + "acceptable range is 1 to 13.  You tried " + value);
        }
        if (suit < 0 || suit > 3) {
            throw new RuntimeException("Illegal suit attempted.  The  "
                    + "acceptable range is 0 to 3.  You tried " + suit);
        }
        this.suit = suit;
        this.value = value;
    }

    /**
     * "Getter" for value of Card.
     * 
     * @return value of card (1-13; 1 for Ace, 2-10 for numerical cards, 11 for
     *         Jack, 12 for Queen, 13 for King)
     */
    public int getValue() {
        return value;
    }

    /**
     * "Getter" for suit of Card.
     * 
     * @return suit of card (0-3; 0 for Spades, 1 for Hearts, 2 for Clubs, 3 for
     *         Diamonds)
     */
    public int getSuit() {
        return suit;
    }

    /**
     * Returns the name of the card as a String. For example, the 2 of hearts
     * would be "2 of h", and the Jack of Spades would be "J of s".
     * 
     * @return string that looks like: value "of" suit
     */
    public String toString() {
        return valueNames[value] + " of " + suitNames[suit];
    }

    /**
     * [STUDENTS SHOULD NOT BE CALLING THIS METHOD!] Used for finding the image
     * corresponding to this Card.
     * 
     * @return path of image file corresponding to this Card.
     */
    public String getImageFileName() {

        String retValue;
        retValue = suitNames[suit];
        if (value <= 10)
            retValue += value;
        else if (value == 11)
            retValue += "j";
        else if (value == 12)
            retValue += "q";
        else if (value == 13)
            retValue += "k";
        else
            retValue += "Unknown!";
        return "images/" + retValue + ".gif";
    }
}

Deck 方法是我需要帮助的方法

public class Deck {

    private Card[] cards;

    public Deck() {
        cards = new Card[52];
        int numberOfCard = 0;
        for (int suit = 0; suit <= 3; suit++) {
            for (int value = 1; value <= 13; value++) {
                cards[numberOfCard] = new Card(value, suit);
                numberOfCard++;
            }
        }
    }

    public Deck(Deck other) {

        cards = new Card[other.cards.length];
        for (int i = 0; i < other.cards.length; i++) {
            cards[i] = other.cards[i];
        }
    }

    public Card getCardAt(int position) {
        if (position >= cards.length) {
            throw new IndexOutOfBoundsException("Values are out of bounds");
        } else {
            return cards[position];
        }
    }

    public int getNumCards() {
        return cards.length;
    }

    public void shuffle() {
        int temp = 0;
        for (int row = 0; row < cards.length; row++) {
            int random = (int) (Math.random() * ((cards.length - row) + 1));
            Deck.this.cards[temp] = this.getCardAt(row);
            cards[row] = cards[random];
            cards[random] = cards[temp];
        }

    }

    public void cut(int position) {
        Deck tempDeck = new Deck();
        int cutNum = tempDeck.getNumCards() / 2;
        for (int i = 0; i < cutNum; i++) {
            tempDeck.cards[i] = this.cards[52 - cutNum + i];
        }
        for (int j = 0; j < 52 - cutNum; j++) {
            tempDeck.cards[j + cutNum] = this.cards[j];
        }
        this.cards = tempDeck.cards;
    }

    public Card[] deal(int numCards) {
        return cards;
    }

}
4

2 回答 2

1

如果您不能使用Lists，那么使用另一个变量与牌组顶牌的索引似乎是个好主意：

public class Deck {

    private Card[] cards;
    private int topCardIndex;

    public Deck() {
        cards = new Card[52];
        int numberOfCard = 0;
        for(int suit = 0; suit <= 3; suit++){
            for(int value = 1; value <= 13; value++){
                cards[numberOfCard] = new Card(value, suit);
                numberOfCard++;
            }
        }
        topCardIndex = 0;
    }

    public Card getCardAt(int position) {
        if (position >= cards.length - topCardIndex || position < topCardIndex) {
            throw new IndexOutOfBoundsException("Values are out of bounds");
        } else {
            return cards[topCardIndex + position];
        }
    }

    public Card[] deal(int numCards) {
        // FIXME: check bounds, or make method "Card pickCardAt(int position)"
        // that removes the card from the deck
        Card[] drawnCards = new Card[numCards];
        for(int index = 0; index < numCards; index ++) {
            drawnCards[index] = cards[topCard];
            topCard++;
        }
        return drawnCards;
    }

我认为将 Deck 的card集合设置为 aList而不是 aCard[]会更好，因此您可以进行更好的操作，例如remove().

如果你想n从牌组中取出第一张牌，那么你只需remove() n次得到你的结果数组（我也会制作一个列表）。

public List<Card> deal(int numCards) {
    List<Card> drawnCards = new ArrayList<Card>(numCards);
    for(int index = 0; index < numCards; index++) {
        drawnCards.add(cards.remove(0));
    }
    return drawnCards;
}
于 2012-11-12T06:00:46.263 回答
0

这就是我在游戏中处理卡片组的方式。我也有 read() 方法从 XML 文件中读取卡片并将它们推入。

import java.util.Stack;

public class CardStack extends Stack<Card> {

    public CardStack () {}

    public void shuffle() {
        List<Card> list = this.subList(0, this.size());
        //changes in this list are reflected in original Stack
        Collections.shuffle(list);
    }

    public Card pop () {
        try {
            Card card = super.pop();
            return card;
        } catch (EmptyStackException e) {
            return null;
        }
    }
}
于 2012-11-12T06:33:44.350 回答