如何在Java数组中生成指定离散值的随机序列

Double[] allowedResults = new Double[] { 0.0, 0.5, 1.0 };

import java.util.Random; // 确保导入Random类

public class ResultGenerator {

    // 定义允许的比赛结果值
    private static final Double[] ALLOWED_RESULTS = new Double[] { 0.0, 0.5, 1.0 };
    // 推荐在类级别创建Random实例，避免在循环中重复创建，影响性能和随机性
    private static final Random RND = new Random();

    /**
     * 从预定义的比赛结果中随机选择一个值。
     * @return 随机选择的比赛结果 (0.0, 0.5 或 1.0)。
     */
    public static Double generateRandomGameResult() {
        // 使用nextInt(bound)方法生成一个介于0（包含）和bound（不包含）之间的随机整数
        // 这里bound是ALLOWED_RESULTS数组的长度
        int randomIndex = RND.nextInt(ALLOWED_RESULTS.length);
        // 返回随机索引对应的数组元素
        return ALLOWED_RESULTS[randomIndex];
    }

    // 主方法或其他业务逻辑将调用此生成器
    public static void main(String[] args) {
        // 示例：生成10个随机比赛结果
        for (int i = 0; i < 10; i++) {
            System.out.println("随机比赛结果: " + generateRandomGameResult());
        }
    }
}

import java.util.Random;
import java.util.Scanner;

public class ChessTournament {

    // 定义允许的比赛结果值
    private static final Double[] ALLOWED_RESULTS = new Double[] { 0.0, 0.5, 1.0 };
    // 推荐在类级别创建Random实例
    private static final Random RND = new Random();

    /**
     * 从预定义的比赛结果中随机选择一个值。
     * @return 随机选择的比赛结果 (0.0, 0.5 或 1.0)。
     */
    public static Double generateRandomGameResult() {
        int randomIndex = RND.nextInt(ALLOWED_RESULTS.length);
        return ALLOWED_RESULTS[randomIndex];
    }

    public static void main(String[] args) {
        // 示例二维数组，用于存储比赛结果
        double a[][] = {{0.5, 0.5, 0.5, 0.5, 0.5},
                        {0, 1, 0, 1, 1},
                        {0.5, 1, 0.5, 0.5, 0},
                        {0, 0.5, 0, 0.5, 0},
                        {1, 1, 1, 1, 1},
                        {0, 0, 0, 0.5, 0.5},
                        {0, 0.5, 0, 0, 1}};
        int i, j;
        int ch;

        System.out.print("请选择操作模式 (1:手动输入, 2:随机生成特定结果, 3:使用已有结果): ");
        Scanner sc = new Scanner(System.in);
        ch = sc.nextInt();

        switch (ch) {
            case 1 -> { // 手动输入模式
                System.out.println("请手动输入比赛结果 (0.0, 0.5 或 1.0):");
                for (i = 0; i < a.length; i++) {
                    for (j = 0; j < a[i].length; j++) {
                        a[i][j] = sc.nextDouble();
                    }
                }
            }
            case 2 -> { // 随机生成特定结果模式
                System.out.println("正在随机生成比赛结果 (0.0, 0.5 或 1.0):");
                for (i = 0; i < a.length; i++) {
                    for (j = 0; j < a[i].length; j++) {
                        a[i][j] = generateRandomGameResult(); // 调用我们创建的生成器
                    }
                }
            }
            case 3 -> { // 使用已有结果模式 (此处为保持原数组内容不变，实际应用中可能从文件或数据库加载)
                System.out.println("正在使用数组中已有的比赛结果。");
                // 实际上这里不需要额外的循环，因为数组a已经初始化
                // 如果是需要从其他地方加载，则在这里实现加载逻辑
                for (i = 0; i < a.length; i++) {
                    for (j = 0; j < a[i].length; j++) {
                        // a[i][j] = a[i][j]; // 这一行是多余的，不改变任何值
                    }
                }
            }
            default -> {
                System.out.println("模式选择错误，程序退出。");
                sc.close();
                return;
            }
        }

        sc.close(); // 关闭Scanner资源

        // 打印最终的比赛结果数组
        System.out.println("\n最终比赛结果:");
        for (i = 0; i < a.length; ++i) {
            for (j = 0; j < a[i].length; ++j) {
                System.out.printf("%.1f " + " ", a[i][j]);
            }
            System.out.println();
        }
    }
}