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

如何生成特定范围内的随机int数值？

我已经尝试了以下方法，但是这些方法不起作用：

尝试1：

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

尝试2：

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

#1楼

我发现此示例生成随机数：

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

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 problemslong range = (long)aEnd - (long)aStart + 1;// compute a fraction of the range, 0 <= frac < rangelong 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.

#2楼

使用此方法可能很方便：

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

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 1return 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;
}

#3楼

采用：

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

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

#4楼

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

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

x，y-间隔，例如（1,10）

#5楼

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

Randomizer.generate(0,10); //min of zero, max of ten

以下是其源代码

Randomizer.java

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

这只是干净和简单。

#6楼

只需使用Random类：

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

#7楼

如果掷骰子，则它是1到6之间的随机数（而不是0到6），因此：

face = 1 + randomNumbers.nextInt(6);

#8楼

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

一切正常。

#9楼

让我们举个例子。

假设我希望生成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

因此，我们获得了所需的范围。

#10楼

使用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值和long整型值进行此操作。

希望能帮助到你！ :)

#11楼

这是一个简单的示例，显示了如何从封闭的[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;}
}

#12楼

只需对您的第一个解决方案进行少量修改就可以了。

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

在此处查看更多有关Random执行的信息

#13楼

最好使用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;
}

#14楼

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

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

#15楼

采用：

minimum + rn.nextInt(maxValue - minvalue + 1)

#16楼

在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 inclusiveint randomNum = rand.nextInt((max - min) + 1) + min;return randomNum;
}

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

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

#17楼

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

#18楼

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

例如： RandomDataGenerator.nextInt或RandomDataGenerator.nextLong

#19楼

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

或查看Apache Commons中的 RandomUtils。

#20楼

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

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

#21楼

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

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

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

Java Math库函数Math.random（）生成[0,1)范围内的双精度值。请注意，此范围不包括1。

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

Math.random() * ( Max - Min )

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

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

Math.random() * 5

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

现在，您需要将此范围上移到您要定位的范围。您可以通过添加最小值来实现。

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

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

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

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

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

那里有它。范围为[Min,Max]或根据示例[5,10]的随机整数值：

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

#22楼

当您需要大量随机数时，建议不要在API中使用Random类。周期太短了。请尝试使用梅森捻线机。有一个Java实现。

#23楼

Java中的Math.Random类基于0。因此，如果您编写如下内容：

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

x将介于0-9到0-9之间（含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） 。

#24楼

我用这个：

 /*** @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;}

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

#25楼

您可以在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);

#26楼

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

rng.nextInt(n)无法达到Integer.MAX_VALUE 。
当min为负数时(max - 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％或更高。

#27楼

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

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

这为您提供了一个介于1（含）和11（不含）之间的随机数，因此请通过添加1来初始化upperBound值。例如，如果要生成介于1到10之间的随机数，请使用11而不是初始化InitialBound数10。

#28楼

从Java 7开始，您不应再使用Random 。对于大多数用途，现在选择的随机数生成器是ThreadLocalRandom 。

对于派生连接池和并行流，请使用SplittableRandom 。

约书亚·布洛赫（Joshua Bloch）。 有效的Java。 第三版。

从Java 8开始

对于派生连接池和并行流，请使用SplittableRandom ，该方法通常更快，与Random相比具有更好的统计独立性和统一性。

生成范围为[0, 1_000]:的随机int [0, 1_000]:

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

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

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

要返回随机值流：

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

#29楼

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

#30楼

另一个选择是仅使用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);// ...}

#31楼

这是一个有用的类，可以在包含范围内的任意ints的范围内生成随机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;}
}