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

Question

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

任务是填充庄家和玩家类的方法。我现在正在经销商处工作，非常感谢任何指导。

现在我的问题是我应该为经销商类中的交易方法返回什么。在 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;
    }
}

Answer 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;
}