Java多米诺发牌程序构建报错及功能实现咨询

问题需求 #

作为Java新手，需要编写程序实现：

• 输入玩家数量
• 将包含91张多米诺牌（每张牌的两个点数范围为0到12，组合为0-0、0-1……12-12，每个无序组合仅出现一次，共91张）的牌组尽可能平均分配给每位玩家，每位玩家获得91 / 玩家数张牌（整数除法）
• 输出格式示例：1st. player: 1-9, 4-12, ...

原代码错误分析 #

• 类体直接写执行代码：Deck类中的循环代码直接放在成员声明后，Java不允许在类体中直接编写可执行语句，必须将代码放在构造方法、普通方法或代码块内。
• 变量未声明类型：内层循环的j未声明int类型，导致编译报错。
• 输出语法错误：System.out.println(twoD_arr \n);写法错误，\n位置不正确，且直接输出数组引用无法打印元素值。
• 牌组数量错误：原循环生成13×13=169张牌，不符合91张的需求，正确的多米诺牌应生成i <= j的点数组合（总数为(13×14)/2=91）。
• 存储结构不合理：二维数组不利于后续洗牌和分发操作，应改用一维集合或数组。
• 手牌数计算冗余：Math.round(91/NumOfPlayers)多余，整数除法91 / NumOfPlayers已满足取整需求。

修正后的完整代码 #

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Domino {
    // 多米诺牌实体类
    static class Tile {
        private int square1;
        private int square2;

        public Tile(int first, int second) {
            this.square1 = first;
            this.square2 = second;
        }

        @Override
        public String toString() {
            return square1 + "-" + square2;
        }
    }

    // 牌组管理类
    static class Deck {
        private List<Tile> tiles;

        public Deck() {
            tiles = new ArrayList<>();
            // 生成91张合法多米诺牌（i <= j，避免重复组合）
            for (int i = 0; i <= 12; i++) {
                for (int j = i; j <= 12; j++) {
                    tiles.add(new Tile(i, j));
                }
            }
            // 洗牌操作
            Collections.shuffle(tiles);
        }

        public List<Tile> getTiles() {
            return tiles;
        }
    }

    // 生成玩家序号后缀（1st、2nd、3rd等）
    private static String getOrdinalSuffix(int number) {
        if (number >= 11 && number <= 13) {
            return "th";
        }
        return switch (number % 10) {
            case 1 -> "st";
            case 2 -> "nd";
            case 3 -> "rd";
            default -> "th";
        };
    }

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.print("Enter the number of players: ");
            int numOfPlayers = scanner.nextInt();

            // 校验玩家数量合法性
            if (numOfPlayers <= 0) {
                System.out.println("Number of players must be positive.");
                return;
            }

            int cardsPerPlayer = 91 / numOfPlayers;
            int remainingCards = 91 % numOfPlayers; // 未分配的剩余牌数

            // 创建并洗牌牌组
            Deck deck = new Deck();
            List<Tile> allTiles = deck.getTiles();

            // 分配牌并输出结果
            int currentIndex = 0;
            for (int i = 1; i <= numOfPlayers; i++) {
                // 若要更平均分配，可让前remainingCards位玩家多拿1张，取消下方注释即可
                // int playerCardCount = cardsPerPlayer + (i <= remainingCards ? 1 : 0);
                int playerCardCount = cardsPerPlayer;

                List<Tile> playerTiles = allTiles.subList(currentIndex, currentIndex + playerCardCount);
                currentIndex += playerCardCount;

                // 格式化输出玩家手牌
                StringBuilder sb = new StringBuilder();
                sb.append(i).append(getOrdinalSuffix(i)).append(". player: ");
                for (int j = 0; j < playerTiles.size(); j++) {
                    sb.append(playerTiles.get(j));
                    if (j != playerTiles.size() - 1) {
                        sb.append(", ");
                    }
                }
                System.out.println(sb);
            }

            // 可选：输出剩余未分配的牌
            if (remainingCards > 0) {
                List<Tile> remaining = allTiles.subList(currentIndex, allTiles.size());
                System.out.println("Remaining cards: " + remaining);
            }
        }
    }
}

代码说明 #

1. Tile类：封装多米诺牌的两个点数，重写toString()方法适配输出格式。
2. Deck类：在构造方法中生成合法的91张牌，通过Collections.shuffle()实现随机洗牌。
3. 序号后缀方法：getOrdinalSuffix()生成符合英文习惯的玩家序号后缀，满足输出格式要求。
4. 主逻辑：
   • 输入玩家数量并做合法性校验
   • 计算每位玩家的手牌数，创建并洗牌牌组
   • 通过subList()截取每位玩家的手牌，格式化输出
   • 可选处理剩余未分配的牌（若91无法被玩家数整除）

内容的提问来源于stack exchange，提问作者PabloSaint