如何在 Java 中生成特定范围内的随机整数？

在 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);

请参阅the relevant 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;
}

请参阅the relevant JavaDoc。在实践中，java.util.Random 类通常优于 java.lang.Math.random()。

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

---

请注意，与 nextInt 方法 https://stackoverflow.com/a/738651/360211 相比，此方法更偏颇且效率更低

实现此目的的一种标准模式是：

Min + (int)(Math.random() * ((Max - Min) + 1))

Java 数学库函数 Math.random() 在 [0,1) 范围内生成一个双精度值。请注意，此范围不包括 1。

为了首先获得特定范围的值，您需要乘以要覆盖的值范围的大小。

Math.random() * ( Max - Min )

这将返回 [0,Max-Min) 范围内的值，其中不包括“Max-Min”。

例如，如果您想要 [5,10)，则需要覆盖五个整数值，以便使用

Math.random() * 5

这将返回 [0,5) 范围内的值，其中不包括 5。

现在您需要将此范围向上移动到您的目标范围。您可以通过添加 Min 值来做到这一点。

Min + (Math.random() * (Max - Min))

您现在将获得范围 [Min,Max) 中的值。按照我们的示例，这意味着 [5,10)：

5 + (Math.random() * (10 - 5))

但是，这仍然不包括 Max 并且您得到的是双精度值。为了获得包含的 Max 值，您需要将 1 添加到您的范围参数 (Max - Min)，然后通过强制转换为 int 来截断小数部分。这是通过以下方式完成的：

Min + (int)(Math.random() * ((Max - Min) + 1))

你有它。范围 [Min,Max] 或示例 [5,10] 中的随机整数值：

5 + (int)(Math.random() * ((10 - 5) + 1))

---

利用：

Random ran = new Random();
int x = ran.nextInt(6) + 5;

整数 x 现在是可能结果为 5-10 的随机数。

---

利用：

minValue + rn.nextInt(maxValue - minValue + 1)

---

对于 java-8，他们在 Random 类中引入了方法 ints(int randomNumberOrigin, int randomNumberBound)。

例如，如果您想在 [0, 10] 范围内生成五个随机整数（或单个整数），只需执行以下操作：

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

第一个参数仅指示生成的 IntStream 的大小（这是产生无限 IntStream 的重载方法）。

如果您需要执行多个单独的调用，您可以从流中创建一个无限的原始迭代器：

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

您也可以对 double 和 long 值执行此操作。我希望它有帮助！ :)

---

您可以将第二个代码示例编辑为：

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;

---

只需对您的第一个解决方案进行小修改就足够了。

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

在此处查看更多关于 Random 的实施

---

ThreadLocalRandom 等效于多线程环境的类 java.util.Random。在每个线程中本地执行随机数的生成。因此，通过减少冲突，我们可以获得更好的性能。

int rand = ThreadLocalRandom.current().nextInt(x,y);

x,y - 间隔，例如 (1,10)

---

Java 中的 Math.Random 类是从 0 开始的。所以，如果你写这样的东西：

Random rand = new Random();
int x = rand.nextInt(10);

x 将介于 0-9 之间。

因此，给定以下 25 项数组，在 0（数组的基数）和 array.length 之间生成随机数的代码将是：

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

由于 i.length 将返回 25，因此 nextInt( i.length ) 将返回一个介于 0-24 范围内的数字。另一个选项与 Math.Random 一起使用，其工作方式相同。

index = (int) Math.floor(Math.random() * i.length);

为了更好地理解，请查看论坛帖子Random Intervals (archive.org)。

---

只需执行以下语句即可完成：

Randomizer.generate(0, 10); // Minimum of zero and maximum of ten

下面是它的源代码。

文件 Randomizer.java

public class Randomizer {
    public static int generate(int min, int max) {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

它既干净又简单。

---

请原谅我的挑剔，但大多数人建议的解决方案，即 min + rng.nextInt(max - min + 1))，似乎很危险，因为：

rng.nextInt(n) 无法达到 Integer.MAX_VALUE。

(max - min) min 为负数时可能会导致溢出。

一个万无一失的解决方案将为 [Integer.MIN_VALUE, Integer.MAX_VALUE] 中的任何 min <= max 返回正确的结果。考虑以下简单的实现：

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

尽管效率低，但请注意 while 循环中的成功概率始终为 50% 或更高。

---

我想知道 Apache Commons Math 库提供的任何随机数生成方法是否符合要求。

例如：RandomDataGenerator.nextInt 或 RandomDataGenerator.nextLong

---

我用这个：

 /**
   * @param min - The minimum.
   * @param max - The maximum.
   * @return A random double between these numbers (inclusive the minimum and maximum).
   */
 public static double getRandom(double min, double max) {
   return (Math.random() * (max + 1 - min)) + min;
 }

如果需要，您可以将其转换为整数。

---

 rand.nextInt((max+1) - min) + min;

---

让我们举个例子。

假设我希望生成一个 5-10 之间的数字：

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

让我们明白这...

用最大值初始化最大值，用最小值初始化最小值。现在，我们需要确定可以获得多少个可能的值。对于此示例，它将是：5、6、7、8、9、10 因此，此计数将为 max - min + 1。即 10 - 5 + 1 = 6 随机数将生成一个介于 0- 之间的数字5.即 0, 1, 2, 3, 4, 5 将最小值添加到随机数将产生： 5, 6, 7, 8, 9, 10 因此我们获得了所需的范围。

---

从 Java 7 开始，您不应再使用 Random。对于大多数用途，选择的随机数生成器现在是 ThreadLocalRandom。对于分叉连接池和并行流，请使用 SplittableRandom。

约书亚·布洛赫。有效的Java。第三版。

从 Java 8 开始

对于分叉连接池和并行流，使用 SplittableRandom，与 Random 相比，它通常更快，具有更好的统计独立性和均匀性属性。

在 [0, 1_000]: 范围内生成随机 int

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

生成范围 [0, 1_000]: 中的随机值 int[100] 数组

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

要返回随机值流：

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

---

使用 nextint(n) 方法为 min 和 max 的差值生成一个随机数，然后将 min 数添加到结果中：

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

---

只需使用 Random 类：

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);

---

要生成“在两个数字之间”的随机数，请使用以下代码：

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

这会给你一个介于 1（包括）和 11（不包括）之间的随机数，所以通过加 1 来初始化 upperBound 值。例如，如果你想生成 1 到 10 之间的随机数，那么用 11 而不是初始化 upperBound 数10.

---

这些方法使用起来可能很方便：

此方法将返回提供的最小值和最大值之间的随机数：

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

并且此方法将从提供的最小值和最大值返回一个随机数（因此生成的数字也可以是最小或最大数字）：

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

---

如果掷骰子，它将是 1 到 6（不是 0 到 6）之间的随机数，所以：

face = 1 + randomNumbers.nextInt(6);

---

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

或者查看 Apache Commons 中的 RandomUtils。

---

这是一个有用的类，可以在包含/排除范围的任意组合的范围内生成随机 ints：

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}

---

您可以在 Java 8 中简洁地实现这一点：

Random random = new Random();

int max = 10;
int min = 5;
int totalNumber = 10;

IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);

---

另一种选择是仅使用 Apache Commons：

import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
    RandomData randomData = new RandomDataImpl();
    int number = randomData.nextInt(5, 10);
    // ...
 }

---

public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
    return pMin + RANDOM.nextFloat() * (pMax - pMin);
}

---

我找到了这个例子 Generate random numbers ：

此示例生成特定范围内的随机整数。

import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

  public static final void main(String... aArgs){
    log("Generating random integers in the range 1..10.");

    int START = 1;
    int END = 10;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }

    log("Done.");
  }

  private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    // compute a fraction of the range, 0 <= frac < range
    long fraction = (long)(range * aRandom.nextDouble());
    int randomNumber =  (int)(fraction + aStart);    
    log("Generated : " + randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
} 

此类的示例运行：

Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.

---

这是一个简单的示例，展示了如何从封闭的 [min, max] 范围生成随机数，而 min <= max is true

您可以将其用作孔类中的字段，同时将所有 Random.class 方法放在一个位置

结果示例：

RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert

资料来源：

import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

    /**
     * @param min generated value. Can't be > then max
     * @param max generated value
     * @return values in closed range [min, max].
     */
    public int nextInt(int min, int max) {
        Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
        if (min == max) {
            return max;
        }

        return nextInt(max - min + 1) + min;
    }
}

---

最好使用 SecureRandom 而不是 Random。

public static int generateRandomInteger(int min, int max) {
    SecureRandom rand = new SecureRandom();
    rand.setSeed(new Date().getTime());
    int randomNum = rand.nextInt((max - min) + 1) + min;
    return randomNum;
}

---

rand.nextInt((max+1) - min) + min;

这工作正常。

---