首页 > 文章 > java教程

Java随机数生成全攻略

时间：2025-08-21 13:14:48 325浏览收藏

“纵有疾风来，人生不言弃”，这句话送给正在学习文章的朋友们，也希望在阅读本文《Java生成随机数方法详解》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新文章相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

在Java中生成随机数主要有两种方式：使用java.util.Random类或java.lang.Math.random()方法。1. java.util.Random更灵活，支持生成整数、浮点数、布尔值及指定范围内的随机数，并可通过设置种子实现可重复序列；2. Math.random()更简单，直接返回0.0到1.0之间的double值。若需生成不重复的随机数，可通过ArrayList检查重复或使用Collections.shuffle提高效率；多线程环境下推荐使用ThreadLocalRandom保证线程安全；此外，还可通过nextGaussian()生成正态分布随机数，结合公式生成指数分布随机数。

如何在Java中生成随机数 Java随机数生成函数用法

在Java中生成随机数，主要依赖java.util.Random类和java.lang.Math.random()方法。前者提供了更丰富的随机数生成选项，后者则更简单直接，返回0.0到1.0之间的double类型随机数。选择哪种方式取决于你的具体需求，例如，是否需要生成特定范围内的整数，或者是否需要控制随机数种子以实现可重复的随机序列。

生成随机数主要有两种方法：使用java.util.Random类或java.lang.Math.random()方法。前者更灵活，后者更简单。

如何使用`java.util.Random`生成随机数

java.util.Random类提供了多种生成随机数的方法，包括生成整数、浮点数以及特定范围内的随机数。

创建Random对象:
```
Random random = new Random();
```
可以传入一个seed作为参数，保证每次运行生成的随机数序列相同。这在调试和测试中非常有用。

生成随机整数:

int randomNumber = random.nextInt(); // 生成一个随机整数
int boundedRandomNumber = random.nextInt(100); // 生成一个0到99之间的随机整数

nextInt()方法可以接受一个整数参数，表示生成的随机数的上限（不包括该上限）。

生成随机浮点数:

double randomDouble = random.nextDouble(); // 生成一个0.0到1.0之间的随机double
float randomFloat = random.nextFloat();   // 生成一个0.0到1.0之间的随机float

生成随机布尔值:

boolean randomBoolean = random.nextBoolean(); // 生成一个随机boolean值（true或false）

控制随机数种子:
```
Random seededRandom = new Random(12345); // 使用种子12345
```
使用相同的种子，每次程序运行时都会生成相同的随机数序列。

如何使用`Math.random()`生成随机数

Math.random()方法返回一个double类型的随机数，范围是[0.0, 1.0)。

生成0.0到1.0之间的随机数:
```
double randomNumber = Math.random();
```
生成指定范围内的随机数:
例如，生成1到100之间的随机整数：
```
int randomNumber = (int)(Math.random() * 100) + 1;
```
这个方法先将Math.random()的结果乘以100，得到0.0到99.999...之间的数，然后强制转换为整数，最后加上1，得到1到100之间的整数。

如何生成指定范围内的随机整数，且避免重复？

生成指定范围内不重复的随机整数，常见的方法是使用java.util.ArrayList来保存已生成的随机数，并在每次生成新随机数时检查是否已存在。

import java.util.ArrayList;
import java.util.Random;

public class UniqueRandomNumbers {
    public static void main(String[] args) {
        int count = 10; // 生成10个不重复的随机数
        int range = 100; // 随机数范围是1到100

        ArrayList uniqueNumbers = new ArrayList<>();
        Random random = new Random();

        while (uniqueNumbers.size() < count) {
            int randomNumber = random.nextInt(range) + 1; // 生成1到100的随机数
            if (!uniqueNumbers.contains(randomNumber)) {
                uniqueNumbers.add(randomNumber);
            }
        }

        System.out.println("生成的随机数: " + uniqueNumbers);
    }
}

这种方法简单直观，但效率较低，特别是当需要生成大量不重复的随机数时。更好的方法是使用java.util.Collections.shuffle()方法，先生成一个包含所有可能值的列表，然后打乱顺序，最后取前count个值。

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

public class UniqueRandomNumbersEfficient {
    public static void main(String[] args) {
        int count = 10; // 生成10个不重复的随机数
        int range = 100; // 随机数范围是1到100

        List numbers = new ArrayList<>();
        for (int i = 1; i <= range; i++) {
            numbers.add(i);
        }

        Collections.shuffle(numbers, new Random()); // 打乱顺序

        List uniqueNumbers = numbers.subList(0, count); // 取前count个

        System.out.println("生成的随机数: " + uniqueNumbers);
    }
}

这种方法效率更高，尤其是在需要生成大量不重复随机数时。

如何保证多线程环境下的随机数生成安全？

在多线程环境下，java.util.Random类的实例可能不是线程安全的。多个线程同时访问同一个Random实例可能会导致竞争条件，从而影响随机数的质量。

使用ThreadLocalRandom:

java.util.concurrent.ThreadLocalRandom是Java 7引入的，它是线程安全的，并且性能更好。

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomExample {
    public static void main(String[] args) {
        ThreadLocalRandom random = ThreadLocalRandom.current();
        int randomNumber = random.nextInt(100); // 生成0到99之间的随机整数
        System.out.println("生成的随机数: " + randomNumber);
    }
}

每个线程都有自己的ThreadLocalRandom实例，避免了线程之间的竞争。

使用synchronized同步块:

如果必须使用java.util.Random，可以使用synchronized关键字来同步对Random实例的访问。

import java.util.Random;

public class SynchronizedRandomExample {
    private static Random random = new Random();

    public static synchronized int getRandomNumber() {
        return random.nextInt(100);
    }

    public static void main(String[] args) {
        int randomNumber = getRandomNumber();
        System.out.println("生成的随机数: " + randomNumber);
    }
}

这种方法可以保证线程安全，但会降低性能，因为多个线程需要等待获取锁。

为每个线程创建独立的Random实例:

另一种方法是为每个线程创建独立的Random实例。

public class IndependentRandomExample {
    private static ThreadLocal random = ThreadLocal.withInitial(Random::new);

    public static int getRandomNumber() {
        return random.get().nextInt(100);
    }

    public static void main(String[] args) {
        int randomNumber = getRandomNumber();
        System.out.println("生成的随机数: " + randomNumber);
    }
}

这种方法避免了线程之间的竞争，但会增加内存消耗。

如何生成符合特定概率分布的随机数？

除了均匀分布的随机数，有时我们需要生成符合特定概率分布的随机数，例如正态分布（高斯分布）或指数分布。

生成正态分布随机数:

java.util.Random类提供了nextGaussian()方法，用于生成符合正态分布的随机数，其均值为0.0，标准差为1.0。

import java.util.Random;

public class GaussianRandomExample {
    public static void main(String[] args) {
        Random random = new Random();
        double gaussianRandom = random.nextGaussian();
        System.out.println("生成的正态分布随机数: " + gaussianRandom);
    }
}

如果需要生成具有不同均值和标准差的正态分布随机数，可以使用以下公式：

X = μ + σ * Z

其中，X是生成的随机数，μ是均值，σ是标准差，Z是nextGaussian()生成的随机数。

double mean = 50.0; // 均值
double standardDeviation = 10.0; // 标准差
double gaussianRandom = mean + standardDeviation * random.nextGaussian();

生成指数分布随机数:

生成指数分布随机数可以使用以下公式：

X = -λ * ln(U)

其中，X是生成的随机数，λ是速率参数，U是0到1之间的均匀分布随机数。

import java.util.Random;

public class ExponentialRandomExample {
    public static void main(String[] args) {
        Random random = new Random();
        double lambda = 0.5; // 速率参数
        double uniformRandom = random.nextDouble();
        double exponentialRandom = -lambda * Math.log(uniformRandom);
        System.out.println("生成的指数分布随机数: " + exponentialRandom);
    }
}

这个例子展示了如何使用Math.log()和nextDouble()来生成指数分布的随机数。

文中关于线程安全,Math.random(),Java随机数,Random类,不重复的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Java随机数生成全攻略》文章吧，也可关注golang学习网公众号了解相关技术文章。

线程安全 Math.random() Java随机数 Random类不重复