Java 17引入了RandomGenerator接口，它提供了一个int nextInt（int origin，int bound）方法来获取范围内的随机整数：

// Returns a random int between minimum (inclusive) & maximum (exclusive)
int randomInt = RandomGenerator.getDefault().nextInt(minimum, maximum);

除了用于Java17中添加的新的随机生成算法之外，该接口还添加到现有的随机生成类（random、SecureRandom、SplitableRandom和ThreadLocalRandom）中。因此，从Java 17开始，这些类具有以下有界nextInt方法：

new Random().nextInt(minimum, maximum);
new SecureRandom().nextInt(minimum, maximum);
new SplittableRandom().nextInt(minimum, maximum);
new ThreadLocalRandom().nextInt(minimum, maximum);

从Java17开始，这种方法是Random和SecureRandom的新方法。在Java17之前，ThreadLocalRandom和SplitableRandom已经有了这个方法，尽管它不是由共享接口指定的。

在A和b之间生成n个随机数的简单方法例如a=90，b=100，n=20

Random r = new Random();
for(int i =0; i<20; i++){
    System.out.println(r.ints(90, 100).iterator().nextInt());
}

r.ints（）返回一个IntStream，并有几个有用的方法，看看它的API。

从Java7开始，您应该不再使用Random。对于大多数用途选择的随机数生成器现在ThreadLocalRandom。用于fork连接池和并行流，使用SplitableRandom。

乔舒亚·布洛赫。有效的Java。第三版。

从Java 8开始

对于fork-join池和并行流，请使用SplittableRandom，它通常更快，与Random相比具有更好的统计独立性和一致性财产。

要生成[0，1_000]范围内的随机整数：

int n = new SplittableRandom().nextInt(0, 1_001);

要生成[0，1_000]范围内的随机整数[100]数组，请执行以下操作：

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

要返回随机值流：

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

在Java 1.7或更高版本中，执行此操作的标准方法如下：

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

请参阅相关的JavaDoc。这种方法的优点是不需要显式初始化java.util.Random实例，如果使用不当，可能会导致混淆和错误。

然而，相反，没有办法明确设置种子，因此在测试或保存游戏状态等有用的情况下，很难再现结果。在这些情况下，可以使用下面所示的Java 1.7之前的技术。

在Java 1.7之前，执行此操作的标准方法如下：

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

请参阅相关的JavaDoc。实际上，java.util.Random类通常比java.lang.Math.Random（）更好。

特别是，当标准库中有一个简单的API来完成任务时，无需重新发明随机整数生成轮。

可以使用以下代码：

ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)

使用Java 8 Streams，

传递初始容量-多少个数字将randomBound从x传递到randomBoud是否为已排序传递true/false传递新的Random（）对象

public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {

    List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());

    if (sorted)
        numbers.sort(null);

    return numbers;
}

在本例中，它从1-Randombound生成数字。