深入理解Math.random()的概率分布特性

直接上源码

/**
 * Returns a {@code double} value with a positive sign, 
 * 返回一个带符号的double类型的数字，说人话就是返回一个非负double类型的数字（包含0）
 *
 * greater than or equal to {@code 0.0} and less than {@code 1.0}.
 * 大于等于0
 * 
 * Returned values are chosen pseudorandomly with (approximately)
 * uniform distribution from that range.
 * 返回一个【伪随机数】，并且返回的值（近似）【均匀分布】
 *
 * <p>When this method is first called, it creates a single new
 * pseudorandom-number generator, exactly as if by the expression
 *
 * <blockquote>{@code new java.util.Random()}</blockquote>
 *
 * This new pseudorandom-number generator is used thereafter for
 * all calls to this method and is used nowhere else.
 *
 * <p>This method is properly synchronized to allow correct use by
 * more than one thread. However, if many threads need to generate
 * pseudorandom numbers at a great rate, it may reduce contention
 * for each thread to have its own pseudorandom-number generator.
 *
 * @return  a pseudorandom {@code double} greater than or equal
 * to {@code 0.0} and less than {@code 1.0}.
 * @see Random#nextDouble()
 */
public static double random() {
    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

核心点

• 返回一个非负double类型数字，返回是[0-1)【包含0不包含1】
• 这是一个伪随机数，真正是随机数应该是没有概率一说
• 产生的没一个随机数的概率近似相等

基础验证：Math.random()随机数等概率

/**
 * Math.random();
 * 返回一个范围[0-1)的double类型数字（包含0，不包括1）
 * 每个数字的返回都是等概率的。
 */
public static void f1() {
    int randomCount = 1000_0000;

    int count = 0;
    double number = 0.1D;
//  double number = 0.2D;
//  double number = 0.3D;
//  double number = 0.4D;
//  double number = 0.5D;
//  double number = 0.6666D;
    for (int i = 0; i < randomCount; i++) {
        if (Math.random() < number) {
            count++;
        }
    }
    System.out.println("随机小于" + number + "的概率：" + (double) count / (double) randomCount);
}

// 分别测试随机的数字小于0.1、0.2、0.3、0.4、0.5、0.6666的概率结果如下：
// 随机小于0.1的概率：0.1000645
// 随机小于0.2的概率：0.2001116
// 随机小于0.3的概率：0.2999759
// 随机小于0.4的概率：0.3999943
// 随机小于0.5的概率：0.5000803
// 随机小于0.6666的概率：0.6665477

根据以上测试发现，我们想要在[0-1)之间获取一个小于x随机数的概率为≈x%。

再次验证：[0-10)随机数等概率

我们知道Math.random()返回一个[0-1)区间的一个随机数，那么把这个随机数放大10倍，我们就能得到一个[0-10)区间的一个随机数。

/**
 * Math.random() * 10;
 * 返回一个范围[0-10)的double类型数字（包含0，不包含10）
 */
public static void f2() {
    int randomCount = 1000_0000;

    // 初始化一个长度为10的数组，每个元素分别记录不同数字产生的个数
    // numbers[0] 存储的是 0 的个数
    // numbers[1] 存储的是 1 的个数
    // ...
    // numbers[9] 存储的是 9 的个数
    int[] numbers = new int[10];
    for (int i = 0; i < randomCount; i++) {
        // 生成的随机数放大10倍，并转换成int类型，这个值一定是[0-10)之间的正整数（包含0，不包含10）
        numbers[(int) (Math.random() * 10)]++;
    }

    for (int i = 0; i < numbers.length; i++) {
        System.out.println("随机小于" + (i + 1) + "的次数：" + numbers[i] + ", 概率是：" + (double) numbers[i] / (double) randomCount);
    }
}

// 测试输出结果如下：
// 随机小于1的次数：999811, 概率是：0.0999811
// 随机小于2的次数：1001029, 概率是：0.1001029
// 随机小于3的次数：1000648, 概率是：0.1000648
// 随机小于4的次数：999331, 概率是：0.0999331
// 随机小于5的次数：1000135, 概率是：0.1000135
// 随机小于6的次数：999298, 概率是：0.0999298
// 随机小于7的次数：998976, 概率是：0.0998976
// 随机小于8的次数：999258, 概率是：0.0999258
// 随机小于9的次数：1001133, 概率是：0.1001133
// 随机小于10的次数：1000381, 概率是：0.1000381

根据以上测试，我们同样能验证想要在[0-10)之间获取一个小于x随机数的概率为≈x%。

问题进阶1：获取一个小于x随机数的概率变成x^2%

还是先上代码

public static void f3() {
    int randomCount = 1000_0000;

    int count = 0;
    double number = 0.456D;
    for (int i = 0; i < randomCount; i++) {
        /**
         * 这里执行了2次随机函数，第一次随机小于number的概率为number%，第二次随机小于nunber的概率也为number%
         * 那么执行两次都小于number的概率就是number*number%，即number^2%。
         * 注意：这里取max是为了保证两次获取的数字都是小于指定的数字。换句话说随机多次中取最大的值都不大于指定的数字，那么其他的数字肯定也不大于指定的数字
         */
        if (Math.max(Math.random(), Math.random()) < number) {
            count++;
        }
    }
    System.out.println("随机小于" + number + "原来的概率：" + number + ", 平方后的概率为：" + Math.pow(number, 2));
    System.out.println("随机小于" + number + "的概率：" + (double) count / (double) randomCount);
}

// 分别测试随机的数字小于0.1、0.2、0.3、0.4、0.5、0.6666的概率结果如下：
// 随机小于0.1原来的概率：0.1, 平方后的概率为：0.010000000000000002
// 随机小于0.1的概率：0.0099795
// 随机小于0.2原来的概率：0.2, 平方后的概率为：0.04000000000000001
// 随机小于0.2的概率：0.040024
// 随机小于0.3原来的概率：0.3, 平方后的概率为：0.09
// 随机小于0.3的概率：0.0900515
// 随机小于0.4原来的概率：0.4, 平方后的概率为：0.16000000000000003
// 随机小于0.4的概率：0.1600157
// 随机小于0.5原来的概率：0.5, 平方后的概率为：0.25
// 随机小于0.5的概率：0.2499815
// 随机小于0.6666原来的概率：0.6666, 平方后的概率为：0.44435556
// 随机小于0.6666的概率：0.4446067

代码中我们执行了两次获取随机数，并取最大值。

我们知道执行一次获取到不大于x的概率为x%，那么连续执行两次都小于x的概率就是x% * x%，即为x^2%。

那么我们这里为什么要取两次随机数的最大值呢？

如果最大值都比x小，那么另外的值肯定也比x小，所以这里表达的意思就是连续两次随机的数字都小于x的概率。

问题进阶2：获取一个小于x随机数的概率变成x^3%

上代码

public static void f4() {
    int randomCount = 1000_0000;

    int count = 0;
//        double number = 0.1D;
//        double number = 0.2D;
//        double number = 0.3D;
//        double number = 0.4D;
//        double number = 0.5D;
        double number = 0.6666D;
    for (int i = 0; i < randomCount; i++) {
        /**
         * 这里执行了2次随机函数，第一次随机小于number的概率为number%，第二次随机小于nunber的概率也为number%，
         * 第三次随机小于nunber的概率也为number%，
         * 那么执行两三次都小于number的概率就是number*number%*number%，即number^3%。
         * 注意：这里取max是为了保证三次获取的数字都是小于指定的数字。换句话说随机多次中取最大的值都不大于指定的数字，那么其他的数字肯定也不大于指定的数字
         */
        if (Math.max(Math.random(), Math.max(Math.random(), Math.random())) < number) {
            count++;
        }
    }
    System.out.println("随机小于" + number + "原来的概率：" + number + ", 立方后的概率为：" + Math.pow(number, 3));
    System.out.println("随机小于" + number + "的概率：" + (double) count / (double) randomCount);
}
// 分别测试随机的数字小于0.1、0.2、0.3、0.4、0.5、0.6666的概率结果如下：
// 随机小于0.1原来的概率：0.1, 立方后的概率为：0.0010000000000000002
// 随机小于0.1的概率：0.001004
// 随机小于0.2原来的概率：0.2, 立方后的概率为：0.008000000000000002
// 随机小于0.2的概率：0.0079951
// 随机小于0.3原来的概率：0.3, 立方后的概率为：0.026999999999999996
// 随机小于0.3的概率：0.0269906
// 随机小于0.4原来的概率：0.4, 立方后的概率为：0.06400000000000002
// 随机小于0.4的概率：0.0641036
// 随机小于0.5原来的概率：0.5, 立方后的概率为：0.125
// 随机小于0.5的概率：0.1250869
// 随机小于0.6666原来的概率：0.6666, 立方后的概率为：0.29620741629599995
// 随机小于0.6666的概率：0.2962848

举一反三：获取一个小于x随机数的概率变成x四次方%

public static void f5() {
    int randomCount = 1000_0000;

    int count = 0;
    double number = 0.456D;
    for (int i = 0; i < randomCount; i++) {
        /**
         * 这里执行了4次随机函数，第一次随机小于number的概率为number%，第二次随机小于nunber的概率也为number%
         * 第3次随机小于number的概率为number%，第4次随机小于nunber的概率也为number%
         * 那么执行四次都小于number的概率就是number*number%*number%*number%，即number四次方%。
         * 注意：这里取max是为了保证多次获取的数字都是小于指定的数字。换句话说随机多次中取最大的值都不大于指定的数字，那么其他的数字肯定也不大于指定的数字
         */
        if (Math.max(Math.random(), Math.max(Math.random(), Math.max(Math.random(), Math.random()))) < number) {
            count++;
        }
    }
    System.out.println("随机小于" + number + "原来的概率：" + number + ", 四次方后的概率为：" + Math.pow(number, 4));
    System.out.println("随机小于" + number + "的概率：" + (double) count / (double) randomCount);
}

以上内容感谢左神。