Java 如何给玩家发一副牌？

我一直在尝试用java创建一个基本的纸牌游戏（实验）。在洗牌后，我需要根据参与游戏的玩家数量，将6张洗牌牌传给每位玩家。（最多6名玩家）

通过在“Player”类中使用setHand（）方法，我可以展示6张牌，但在游戏开始后，在main方法中，通过循环玩家，如果有两个玩家，我只能看到2张牌

    public static void main (String[] args) {
        //Create players between 2-6
        Game newGame = new Game();
        List<Player> players = newGame.createPlayers();

        //Let user decide the number of cards set either 24 or 36 or 52 and create deck
        if(players != null){
            newGame.createDeck(players);

            for (Player player: players){
                    player.showHand();
            }
        }

    }

publicstaticvoidmain（字符串[]args）{
//创造2-6人之间的球员
Game newGame=新游戏（）；
List players=newGame.createPlayers（）；
//让用户决定24张、36张或52张牌的数量，然后创建牌组
如果（玩家！=null）{
newGame.createDeck（玩家）；
用于（玩家：玩家）{
player.showHand（）；
}
}
}

公共类游戏{
私人交易商；
private List players=new ArrayList（）；
私人球员；
公开名单{
扫描仪=新的扫描仪（System.in）；
System.out.println（“玩家数量（最多6）”；
numberOfPlayers=scanner.nextInt（）；
如果（numberOfPlayers如注释中所述，通常最好将您的问题合并成一个简短的代码示例来说明问题。调试器也是您的朋友，设置断点并逐步确定变量值是否与您在应用程序的不同点中期望的值相匹配

您没有看到想要的结果的原因是由于
dealShuffledCardsToPlayers（…）
和
deck.deal（…）
方法中的逻辑

让我们从deck.deal（int-size）方法的内部开始

但是每次你设置它时，它只是你从牌组中移除的一张（最后一张）牌。deal（…）方法，这就是为什么你最终每个玩家只有一张牌

我想你所说的是让
牌组.发（…）
方法发6张随机牌，然后返回手牌，大致如下：

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

添加打印在卡片打印输出上方的播放器名称后（为了在调试日志中清晰起见），设置3个随机播放器时，您将得到以下结果：

Number of players(up to 6)
3
Please enter the names
George
Please enter the names
Maria
Please enter the names
Joe
Number of Cards (24/36/52)
52
Player: George
FOUR of DIAMONDS
TEN of DIAMONDS
THREE of CLUBS
TWO of CLUBS
NINE of SPADES
EIGHT of SPADES

Player: Maria
TWO of DIAMONDS
KING of CLUBS
FOUR of SPADES
FIVE of HEARTS
JACK of SPADES
SEVEN of DIAMONDS

Player: Joe
NINE of HEARTS
JACK of HEARTS
FIVE of DIAMONDS
ACE of CLUBS
ACE of SPADES
JACK of CLUBS


另一件事是你很可能想要防止玩家/牌数的不直接组合——也就是说，如果你的牌数只有24张，你不可能有一个6人游戏，每个玩家发6张牌

编辑--插入示例的修改类：

Dealer.java

public class Dealer {
    private Deck deck;
    private List<Player> players;
    private final int NUMBER_OF_CARDS;

    public Dealer(int numberOfCards, int numberOfPlayers) {
        this.deck = new Deck(numberOfCards);
        this.players = new ArrayList<>(numberOfPlayers);
        this.NUMBER_OF_CARDS = numberOfCards;
    }

    public void shuffleDeck(){
        Collections.shuffle(deck.getDeck());
    }

    public void dealShuffledCardsToPlayers(List<Player> players){
//        List<Card> tempCard = deck.getDeck();
//        for(int i=0; i < players.size(); i++){
//            for(int j=0; j < 6; j++){
//                players.add(tempCard.remove(i+j*6));
//            }
//        }
        for(Player player: players){
            player.setHand(deck.deal(6));
        }
    }
}

公共类经销商{
私人甲板；
私人名单玩家；
卡的专用最终整数编号；
公共交易商（int numberOfCards，int NumberOfPlayer）{
this.deck=新甲板（卡片数量）；
this.players=新阵列列表（numberOfPlayers）；
这是。卡片的数量=卡片的数量；
}
公共空间{
Collections.shuffle（deck.getDeck（））；
}
public void dealShuffledCardsToPlayers（列出玩家）{
//List tempCard=deck.getDeck（）；
//对于（int i=0；i

Deck.java

public class Deck{
    private List<Card> deck;
    //    private static final Random GENERATOR = new Random();
    public Deck (int numberOfCards) {
        deck = new ArrayList<>(numberOfCards);

        int count = 0;

        for (final Card.Suit suit : Card.Suit.values()) {
            for (final Card.Rank rank : Card.Rank.values()) {
                deck.add(new Card(rank, suit));
                count++;
            }
        }
    }

    public List<Card> getDeck(){
        return deck;
    }

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        for(int i = 0; i < deck.size(); i++){
            builder.append(i + " ");
            builder.append(deck.get(i));
            builder.append(System.getProperty("line.separator"));
        }
        return builder.toString();
    }
}

公共类甲板{
私人名单组；
//专用静态最终随机生成器=新随机（）；
公共甲板（国际号码卡）{
deck=新阵列列表（卡片数量）；
整数计数=0；
对于（最后一张牌。套装：Card.Suit.values（））{
对于（最后一张卡。等级：Card.Rank.values（））{
牌组。添加（新牌（等级、套装））；
计数++；
}
}
}
公共列表getDeck（）{
返回甲板；
}
公开列表交易（整数大小）{
列表手=新阵列列表（大小）；
Random rand=新的Random（）；
对于（int dealtCount=0；dealtCount
请在显示相关代码的同时，将问题中的代码编辑得尽可能简单。使用调试器跟踪您的代码？我编辑代码有点简单谢谢您的建议，R4N。我的缺点是，尽管我确实知道您建议的各个部分，但我无法将它们全部呈现在屏幕上现在，我要看大局。当然，这需要越来越多的练习，但在这种情况下，您的建议是什么？@user574712我编辑了我的回复，将我的建议包括在内，以便将您想要的结果插入到两个类中（Deck和Dealer）。
public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        hand.add(deck.remove(size));
        return hand;
    }

for(Player player: players){
            for(int i= 0; i<6; i++) {
                player.setHand(deck.deal(6));
            }
        }


    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

        for(Player player: players){
            player.setHand(deck.deal(6));
        }

Number of players(up to 6)
3
Please enter the names
George
Please enter the names
Maria
Please enter the names
Joe
Number of Cards (24/36/52)
52
Player: George
FOUR of DIAMONDS
TEN of DIAMONDS
THREE of CLUBS
TWO of CLUBS
NINE of SPADES
EIGHT of SPADES

Player: Maria
TWO of DIAMONDS
KING of CLUBS
FOUR of SPADES
FIVE of HEARTS
JACK of SPADES
SEVEN of DIAMONDS

Player: Joe
NINE of HEARTS
JACK of HEARTS
FIVE of DIAMONDS
ACE of CLUBS
ACE of SPADES
JACK of CLUBS


public class Dealer {
    private Deck deck;
    private List<Player> players;
    private final int NUMBER_OF_CARDS;

    public Dealer(int numberOfCards, int numberOfPlayers) {
        this.deck = new Deck(numberOfCards);
        this.players = new ArrayList<>(numberOfPlayers);
        this.NUMBER_OF_CARDS = numberOfCards;
    }

    public void shuffleDeck(){
        Collections.shuffle(deck.getDeck());
    }

    public void dealShuffledCardsToPlayers(List<Player> players){
//        List<Card> tempCard = deck.getDeck();
//        for(int i=0; i < players.size(); i++){
//            for(int j=0; j < 6; j++){
//                players.add(tempCard.remove(i+j*6));
//            }
//        }
        for(Player player: players){
            player.setHand(deck.deal(6));
        }
    }
}

public class Deck{
    private List<Card> deck;
    //    private static final Random GENERATOR = new Random();
    public Deck (int numberOfCards) {
        deck = new ArrayList<>(numberOfCards);

        int count = 0;

        for (final Card.Suit suit : Card.Suit.values()) {
            for (final Card.Rank rank : Card.Rank.values()) {
                deck.add(new Card(rank, suit));
                count++;
            }
        }
    }

    public List<Card> getDeck(){
        return deck;
    }

    public List<Card> deal(int size){
        List<Card> hand = new ArrayList<>(size);
        Random rand = new Random();
        for (int dealtCount = 0; dealtCount < size; dealtCount++) {
            hand.add(deck.remove(rand.nextInt(deck.size())));
        }
        return hand;
    }

    @Override
    public String toString(){
        StringBuilder builder = new StringBuilder();
        for(int i = 0; i < deck.size(); i++){
            builder.append(i + " ");
            builder.append(deck.get(i));
            builder.append(System.getProperty("line.separator"));
        }
        return builder.toString();
    }
}