Java中在数组内生成指定离散随机数的实用指南

import java.util.Random;

public class DiscreteRandomGenerator {

    // 推荐使用一个静态final的Random实例，以避免重复创建对象和潜在的随机性问题
    private static final Random RND = new Random();

    /**
     * 生成一个随机的离散值，从预定义的集合 {0.0, 0.5, 1.0} 中选取。
     * 适用于棋类比赛结果等需要特定数值的场景。
     *
     * @return 0.0, 0.5 或 1.0 之一。
     */
    public static Double generateSpecificDiscreteRandom() {
        // 定义所有允许的离散值
        Double[] possibleValues = new Double[] { 0.0, 0.5, 1.0 };
        // 随机选择一个索引
        int randomIndex = RND.nextInt(possibleValues.length);
        // 返回对应索引的值
        return possibleValues[randomIndex];
    }

    // 主方法，用于演示如何使用此生成器
    public static void main(String[] args) {
        System.out.println("生成10个随机离散值:");
        for (int i = 0; i < 10; i++) {
            System.out.printf("%.1f ", generateSpecificDiscreteRandom());
        }
        System.out.println();
    }
}

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

public class ChessTournamentManager {

    // 保持Random实例的单一性，提高效率和随机性质量
    private static final Random RND = new Random();

    /**
     * 生成一个随机的棋局结果（0.0代表输，0.5代表平局，1.0代表赢）。
     *
     * @return 0.0, 0.5 或 1.0 之一。
     */
    public static Double generateGameResult() {
        Double[] possibleResults = new Double[] { 0.0, 0.5, 1.0 };
        int randomIndex = RND.nextInt(possibleResults.length);
        return possibleResults[randomIndex];
    }

    public static void main(String[] args) {
        // 示例：一个二维数组用于存储比赛结果
        double[][] gameResultsMatrix = {
            {0.5, 0.5, 0.5, 0.5, 0.5},
            {0.0, 1.0, 0.0, 1.0, 1.0},
            {0.5, 1.0, 0.5, 0.5, 0.0},
            {0.0, 0.5, 0.0, 0.5, 0.0},
            {1.0, 1.0, 1.0, 1.0, 1.0}
        };

        Scanner scanner = new Scanner(System.in);
        System.out.print("请选择操作模式 (1: 手动输入, 2: 随机生成特定结果, 3: 使用初始数据): ");
        int choice = scanner.nextInt();

        switch (choice) {
            case 1 -> { // 手动输入模式
                System.out.println("请输入比赛结果 (0.0, 0.5, 1.0):");
                for (int i = 0; i < gameResultsMatrix.length; i++) {
                    for (int j = 0; j < gameResultsMatrix[i].length; j++) {
                        gameResultsMatrix[i][j] = scanner.nextDouble();
                    }
                }
            }
            case 2 -> { // 随机生成特定结果模式
                for (int i = 0; i < gameResultsMatrix.length; i++) {
                    for (int j = 0; j < gameResultsMatrix[i].length; j++) {
                        gameResultsMatrix[i][j] = generateGameResult(); // 调用封装的生成方法
                    }
                }
                System.out.println("已随机生成比赛结果。");
            }
            case 3 -> { // 使用初始数据模式
                System.out.println("已使用初始数据。");
                // 数组 gameResultsMatrix 已经有初始值，此模式下无需额外操作
            }
            default -> {
                System.out.println("无效的模式选择，程序退出。");
                scanner.close();
                return;
            }
        }

        scanner.close(); // 关闭Scanner

        // 打印最终的比赛结果矩阵
        System.out.println("\n--- 最终比赛结果矩阵 ---");
        for (double[] row : gameResultsMatrix) {
            for (double result : row) {
                System.out.printf("%.1f ", result);
            }
            System.out.println();
        }
    }
}