Java中实现灵活且简洁的概率分布机制

Random random = new Random();
int randomInt = random.nextInt(10) + 1; // 生成1到10之间的随机整数

if (randomInt <= 3) { // 30%概率
    System.out.println("事件A发生");
} else if (randomInt <= 8) { // 50%概率 (3 < randomInt <= 8)
    System.out.println("事件B发生");
} else { // 20%概率 (randomInt > 8)
    System.out.println("事件C发生");
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 一个泛型化的加权随机选择器。
 * 允许为不同值分配权重，并根据权重进行随机选择。
 * 权重不需要归一化，且可以动态添加。
 *
 * @param <T> 要进行加权随机选择的值的类型
 */
public class WeightedRandom<T> {

    // 内部类，用于存储值及其权重
    private static class WeightedValue<T> {
        final double weight; // 权重
        final T value;      // 对应的值

        public WeightedValue(double weight, T value) {
            this.weight = weight;
            this.value = value;
        }
    }

    // 比较器，用于按权重降序排序 WeightedValue
    // 权重较高的项会排在前面，有助于在next()方法中更快匹配
    private final Comparator<WeightedValue<T>> byWeight =
        Comparator.comparing((WeightedValue<T> wv) -> wv.weight).reversed();

    // 使用TreeSet存储WeightedValue，并根据byWeight比较器自动排序
    private final Set<WeightedValue<T>> weightedValues =
        new TreeSet<>(byWeight);

    private double totalWeight; // 所有权重的总和

    /**
     * 添加一个带权重的值到选择器中。
     * 如果权重小于等于0，则不添加。
     *
     * @param weight 值的权重，必须大于0
     * @param value  要添加的值
     */
    public void put(double weight, T value) {
        if (weight <= 0) {
            // 负权重或零权重没有意义，直接忽略
            return;
        }
        totalWeight += weight; // 更新总权重
        weightedValues.add(new WeightedValue<>(weight, value)); // 添加到集合中
    }

    /**
     * 根据已添加的权重进行随机选择，并返回一个值。
     *
     * @return 根据权重随机选择的值
     * @throws NoSuchElementException 如果没有添加任何值，则抛出此异常
     */
    public T next() {
        if (weightedValues.isEmpty()) {
            throw new NoSuchElementException("WeightedRandom is empty, no elements to choose from.");
        }

        // 生成一个 [0, totalWeight) 范围内的随机数
        // 使用ThreadLocalRandom比new Random()在多线程环境下性能更好
        double rnd = ThreadLocalRandom.current().nextDouble(totalWeight);
        double sum = 0; // 累加权重

        // 迭代器遍历按权重降序排列的WeightedValue
        Iterator<WeightedValue<T>> iterator = weightedValues.iterator();
        WeightedValue<T> result;

        // 遍历直到累加权重超过随机数
        do {
            result = iterator.next();
            sum += result.weight;
        } while (rnd >= sum && iterator.hasNext()); // 注意这里使用rnd >= sum，确保即使rnd等于sum也能选中当前项

        return result.value;
    }
}

public class WeightedRandomExample {
    public static void main(String[] args) {
        // 创建一个用于字符串的加权随机选择器
        WeightedRandom<String> randomSelector = new WeightedRandom<>();

        // 添加带权重的事件
        // "AAA" 权重 3 (对应30%概率)
        // "BBB" 权重 2 (对应20%概率)
        // "CCC" 权重 5 (对应50%概率)
        randomSelector.put(3, "AAA");
        randomSelector.put(2, "BBB");
        randomSelector.put(5, "CCC");

        // 模拟1000次随机选择，并统计结果
        int countA = 0;
        int countB = 0;
        int countC = 0;

        System.out.println("进行1000次加权随机选择：");
        for (int i = 0; i < 1000; i++) {
            String value = randomSelector.next();
            // System.out.println(value); // 如果需要打印每次结果

            switch (value) {
                case "AAA":
                    countA++;
                    break;
                case "BBB":
                    countB++;
                    break;
                case "CCC":
                    countC++;
                    break;
            }
        }

        System.out.println("\n--- 统计结果 ---");
        System.out.printf("AAA 出现次数: %d (%.2f%%)%n", countA, (double) countA / 1000 * 100);
        System.out.printf("BBB 出现次数: %d (%.2f%%)%n", countB, (double) countB / 1000 * 100);
        System.out.printf("CCC 出现次数: %d (%.2f%%)%n", countC, (double) countC / 1000 * 100);

        // 示例：添加新事件并再次尝试
        System.out.println("\n--- 添加新事件并再次模拟 ---");
        randomSelector.put(1, "DDD"); // 添加一个权重为1的新事件
        int countD = 0;
        for (int i = 0; i < 1000; i++) {
            String value = randomSelector.next();
            if ("DDD".equals(value)) {
                countD++;
            }
        }
        System.out.printf("DDD 出现次数: %d (%.2f%%)%n", countD, (double) countD / 1000 * 100);
        // 其他事件的概率也会相应调整，因为总权重增加了
    }
}