java扑克程序不知道返回什么答案

【问题标题】：java poker program don't know what to returnjava扑克程序不知道返回什么
【发布时间】：2016-07-16 00:18:46
【问题描述】：

首先，这是一项任务，但我真的迷失了系统的这一部分。

任务是填写经销商和玩家类的方法。我现在在经销商处工作，希望得到任何指导。

现在我的问题是我应该在我的经销商类中为我的交易方法返回什么。在 main 中，您可以看到它被调用并且需要返回值，以便它可以显示当前的 5 张卡片，但无论我尝试什么，它都会返回错误。

我试过了：

return dealCard and return Card;

也在我的：

dealCard[i] = tempCards.get(i);

我遇到了一个问题，当它已经在第 10 个循环中时，它返回一个错误说 index 4 size 3，到第 10 个循环时，我指的是 play 方法所在的主类循环 10 次，因此我的 deal 方法也将被调用 10 次。如果这似乎是一件微不足道的事情，我提前道歉，但我还没有真正深入研究 Java，我还在学习，我不习惯 OOP。

主要：

public class Poker {
    private static final int NUMBER_OF_HANDS = 10;

    public static void main(String... args) {
        Dealer dealer = new DealerImpl();
        Player player = new PlayerImpl();
        Deck deck = new Deck();

        dealer.shuffle(deck);

        for (int i = 0; i < NUMBER_OF_HANDS; i++) {
            try {
                play(dealer, player, deck);
            } catch (OutOfCardsException e) {
                throw new IllegalStateException();
            }
        }
    }

    private static void play(Dealer dealer, Player player, Deck deck)
            throws OutOfCardsException {

        Hand hand = dealer.deal(deck);
        Result result = player.evaluate(hand);

        System.out.println(format("%s \u21d2 %s", hand, result));
    }
}

手课

public class Hand {
    public static final int NUMBER_OF_CARDS = 5;

    private Set<Card> cards;

    public Hand(Set<Card> cards) {
        if (cards.size() != NUMBER_OF_CARDS) {
            String message = format("%d cards needed in one hand",
                    NUMBER_OF_CARDS);

            throw new IllegalArgumentException(message);
        }

        this.cards = cards;
    }

    public Set<Card> getCards() {
        return cards;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();

        for (Card card : cards) {
            stringBuilder.append(card.toString());
        }

        return stringBuilder.toString();
    }
}

甲板：

public class Deck {
    private List<Card> cards = new ArrayList<>();

    public Deck() {
        for (Card card : Card.values()) {
            cards.add(card);
        }
    }

    public List<Card> getCards() {
        return cards;
    }
}

经销商：

public class DealerImpl implements Dealer {

    @Override
    public void shuffle(Deck deck) {
            Collections.shuffle(deck.getCards());
    }

    @Override
    public Hand deal(Deck deck) throws OutOfCardsException {
            List<Card> tempCards = deck.getCards();

            int n = 5;
            Card[] dealCard = new Card[n];
            if(tempCards.size() >= 5){
                for(int i = 0; i< n; i++){
                // what I'm trying to do here is to get 5 cards from the deck and remove them 
                // so that they cannot be repeated. I am doing it right?
                    dealCard[i] = tempCards.get(i);
                    tempCards.remove(0);
                }
            }
            return null;
    }
}

卡片：

public enum Card {
    ACE_OF_DIAMONDS(DIAMONDS, ACE, new String(new int[] {0x1f0c1}, 0, 1)),
    TWO_OF_DIAMONDS(DIAMONDS, TWO, new String(new int[] {0x1f0c2}, 0, 1)),
    THREE_OF_DIAMONDS(DIAMONDS, THREE, new String(new int[] {0x1f0c3}, 0, 1)),
    FOUR_OF_DIAMONDS(DIAMONDS, FOUR, new String(new int[] {0x1f0c4}, 0, 1)),
    FIVE_OF_DIAMONDS(DIAMONDS, FIVE, new String(new int[] {0x1f0c5}, 0, 1)),
    SIX_OF_DIAMONDS(DIAMONDS, SIX, new String(new int[] {0x1f0c6}, 0, 1)),
    SEVEN_OF_DIAMONDS(DIAMONDS, SEVEN, new String(new int[] {0x1f0c7}, 0, 1)),
    EIGHT_OF_DIAMONDS(DIAMONDS, EIGHT, new String(new int[] {0x1f0c8}, 0, 1)),
    NINE_OF_DIAMONDS(DIAMONDS, NINE, new String(new int[] {0x1f0c9}, 0, 1)),
    TEN_OF_DIAMONDS(DIAMONDS, TEN, new String(new int[] {0x1f0ca}, 0, 1)),
    JACK_OF_DIAMONDS(DIAMONDS, JACK, new String(new int[] {0x1f0cb}, 0, 1)),
    QUEEN_OF_DIAMONDS(DIAMONDS, QUEEN, new String(new int[] {0x1f0cd}, 0, 1)),
    KING_OF_DIAMONDS(DIAMONDS, KING, new String(new int[] {0x1f0ce}, 0, 1)),
    ACE_OF_CLUBS(CLUBS, ACE, new String(new int[] {0x1f0d1}, 0, 1)),
    TWO_OF_CLUBS(CLUBS, TWO, new String(new int[] {0x1f0d2}, 0, 1)),
    THREE_OF_CLUBS(CLUBS, THREE, new String(new int[] {0x1f0d3}, 0, 1)),
    FOUR_OF_CLUBS(CLUBS, FOUR, new String(new int[] {0x1f0d4}, 0, 1)),
    FIVE_OF_CLUBS(CLUBS, FIVE, new String(new int[] {0x1f0d5}, 0, 1)),
    SIX_OF_CLUBS(CLUBS, SIX, new String(new int[] {0x1f0d6}, 0, 1)),
    SEVEN_OF_CLUBS(CLUBS, SEVEN, new String(new int[] {0x1f0d7}, 0, 1)),
    EIGHT_OF_CLUBS(CLUBS, EIGHT, new String(new int[] {0x1f0d8}, 0, 1)),
    NINE_OF_CLUBS(CLUBS, NINE, new String(new int[] {0x1f0d9}, 0, 1)),
    TEN_OF_CLUBS(CLUBS, TEN, new String(new int[] {0x1f0da}, 0, 1)),
    JACK_OF_CLUBS(CLUBS, JACK, new String(new int[] {0x1f0db}, 0, 1)),
    QUEEN_OF_CLUBS(CLUBS, QUEEN, new String(new int[] {0x1f0dd}, 0, 1)),
    KING_OF_CLUBS(CLUBS, KING, new String(new int[] {0x1f0de}, 0, 1)),
    ACE_OF_HEARTS(HEARTS, ACE, new String(new int[] {0x1f0b1}, 0, 1)),
    TWO_OF_HEARTS(HEARTS, TWO, new String(new int[] {0x1f0b2}, 0, 1)),
    THREE_OF_HEARTS(HEARTS, THREE, new String(new int[] {0x1f0b3}, 0, 1)),
    FOUR_OF_HEARTS(HEARTS, FOUR, new String(new int[] {0x1f0b4}, 0, 1)),
    FIVE_OF_HEARTS(HEARTS, FIVE, new String(new int[] {0x1f0b5}, 0, 1)),
    SIX_OF_HEARTS(HEARTS, SIX, new String(new int[] {0x1f0b6}, 0, 1)),
    SEVEN_OF_HEARTS(HEARTS, SEVEN, new String(new int[] {0x1f0b7}, 0, 1)),
    EIGHT_OF_HEARTS(HEARTS, EIGHT, new String(new int[] {0x1f0b8}, 0, 1)),
    NINE_OF_HEARTS(HEARTS, NINE, new String(new int[] {0x1f0b9}, 0, 1)),
    TEN_OF_HEARTS(HEARTS, TEN, new String(new int[] {0x1f0ba}, 0, 1)),
    JACK_OF_HEARTS(HEARTS, JACK, new String(new int[] {0x1f0bb}, 0, 1)),
    QUEEN_OF_HEARTS(HEARTS, QUEEN, new String(new int[] {0x1f0bd}, 0, 1)),
    KING_OF_HEARTS(HEARTS, KING, new String(new int[] {0x1f0be}, 0, 1)),
    ACE_OF_SPADES(SPADES, ACE, new String(new int[] {0x1f0a1}, 0, 1)),
    TWO_OF_SPADES(SPADES, TWO, new String(new int[] {0x1f0a2}, 0, 1)),
    THREE_OF_SPADES(SPADES, THREE, new String(new int[] {0x1f0a3}, 0, 1)),
    FOUR_OF_SPADES(SPADES, FOUR, new String(new int[] {0x1f0a4}, 0, 1)),
    FIVE_OF_SPADES(SPADES, FIVE, new String(new int[] {0x1f0a5}, 0, 1)),
    SIX_OF_SPADES(SPADES, SIX, new String(new int[] {0x1f0a6}, 0, 1)),
    SEVEN_OF_SPADES(SPADES, SEVEN, new String(new int[] {0x1f0a7}, 0, 1)),
    EIGHT_OF_SPADES(SPADES, EIGHT, new String(new int[] {0x1f0a8}, 0, 1)),
    NINE_OF_SPADES(SPADES, NINE, new String(new int[] {0x1f0a9}, 0, 1)),
    TEN_OF_SPADES(SPADES, TEN, new String(new int[] {0x1f0aa}, 0, 1)),
    JACK_OF_SPADES(SPADES, JACK, new String(new int[] {0x1f0ab}, 0, 1)),
    QUEEN_OF_SPADES(SPADES, QUEEN, new String(new int[] {0x1f0ad}, 0, 1)),
    KING_OF_SPADES(SPADES, KING, new String(new int[] {0x1f0ae}, 0, 1));

    private Suit suit;
    private Rank rank;
    private String string;

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

    public Suit getSuit() {
        return suit;
    }

    public void setSuit(Suit suit) {
        this.suit = suit;
    }

    public Rank getRank() {
        return rank;
    }

    public void setRank(Rank rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        return string;
    }
}

【问题讨论】：

什么是错误/堆栈跟踪？我想我发现public Hand deal(Deck deck) 中的循环有问题，错误跟踪将帮助我确认。
您询问要返回什么，但方法签名要求您返回 Hand 对象。只需返回一个新的 Hand(tempCards)，将 List 转换为 Set（不是 100% 确定这是必要的，我的 java 有点生锈）
它只说 index 4 size 3，我相信它已经用完了卡，但应该还没用完。
@GordonAllocman 它给出了这个错误 java.util.ArrayList cannot be cast to java.util.Set，在我把它变成 return new Hand((Set) tempCards);
@makingitwork 您需要转换的不仅仅是演员表。看到这个SO answer 注意最上面的评论，如果传入的列表为空，你会得到一个 NPE

标签： java return

【解决方案1】：

remove 方法将所有剩余对象向左移动，因此当您到达索引 4 时，它不再存在于列表中。

你可以从牌组的末尾开始交易

for(int i = n - 1; i >= 0; i--) {
    dealCard[i] = tempCards.get(i);
    tempCards.remove(tempCards.size() - 1);
}

返回Hand 将dealcards 转换为Set 并返回新的Hand

Set<Card> cards = new HashSet<Card>(Arrays.asList(dealCard));

return new Hand(cards);

deal 方法如下所示

@Override
public Hand deal(Deck deck) throws OutOfCardsException {
    List<Card> tempCards = deck.getCards();

    int n = 5;
    Card[] dealCard = new Card[n];
    if(tempCards.size() >= 5) {
        for(int i = n - 1; i >= 0; i--) {
            dealCard[i] = tempCards.get(i);
            tempCards.remove(tempCards.size() - 1);
        }

        Set<Card> cards = new HashSet<Card>(Arrays.asList(dealCard));

        return new Hand(cards);
    }

    return null;
}

【讨论】：

感谢它运行没有错误，但现在的问题是 Hand 类没有正确解释返回值。
根据需求的预期输出是卡片的一些图形，你可以在卡片类中看到。但我的交易方法的输出是?????。这意味着它无法识别要显示的卡片。我想知道我哪里出错了。非常感谢您的指导
netbeans 似乎遇到了 unicode 问题，因为这个 "\u21d2" 也没有正确显示
@makingitwork new String(new int[] {0x1f0ae}, 0, 1) 在将其转换为 int 字符串时返回奇数符号。你到底想在那里打印什么？
我认为它作为\u21d2的unicode问题显示为？，应该是什么时候=>

【解决方案2】：

我确实看到了这里的问题。 dealCard 数组有 5 个项目。在 for 循环中，您正在寻找 6 张卡片。数组索引从 0 开始。另一个问题是每次移除卡片时列表大小都会发生变化。抓住 0 卡而不是 (i)。每次您进行移除时，0 卡都会成为“下一张”卡。

@Override
    public Hand deal(Deck deck) throws OutOfCardsException {
            List<Card> tempCards = deck.getCards();

            int n = 5;
            Card[] dealCard = new Card[n];
            if(tempCards.size() >= 5){
                for(int i = 0; i< n; i++){
                // what I'm trying to do here is to get 5 cards from the deck and remove them 
                // so that they cannot be repeated. I am doing it right?
                    dealCard[i] = tempCards.get(i);
                    tempCards.remove(0);
                }
            }
            return null;
    }

将其更改为：

@Override
public Hand deal(Deck deck) throws OutOfCardsException {
        List<Card> tempCards = deck.getCards();

        int n = 5;
        Card[] dealCard = new Card[n];
        if(tempCards.size() >= 5){
            for(int i = 0; i< n-1; i++){
            // what I'm trying to do here is to get 5 cards from the deck and remove them 
            // so that they cannot be repeated. I am doing it right?
                dealCard[i] = tempCards.get(0);
                tempCards.remove(0);
            }
        }
        //return a hand. Cast the Array to a set, and create a new hand.
        Set<Card> mySet = new HashSet<Card>(dealCard);
        return new Hand(Arrays.asList(mySet));

}

for 循环现在转到 n-1。

【讨论】：

这可能会解决他的越界异常，但应该是 tempCards.get(0) ，否则它不会做他认为它正在做的事情。例如，当 i 为 1 时，他正在抓取最初在索引 2 中的内容，因为列表缩小了。
@GordonAllocman 你是对的。我没有考虑到remove(0)。
@kevingreen 循环错误消失了，剩下的就是返回什么
这个答案不正确。 for(int i = 0; i< n; i++) i < n-1 代码。如果 i == 5（超出范围），则 i 不小于 n，它会中断循环。
而且，也许，你应该让 if 语句符合你正在发牌的数量，而不是硬编码为 5。即。 int n = 5; if (tempCards.size() >= n) {...}

【解决方案3】：

由于您的方法的返回类型为Hand，因此您必须返回一个具有Hand 类型的对象。

还可以使用 kevingreen 的解决方案来解决您的阵列问题。

【讨论】：