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

我试图用Java生成一个随机的int值，但是在一个特定的范围内。

例如：

我的范围是5 – 10 ，这意味着5是最小的可能值， 10是最大的。 这些数字之间的任何其他数字也可能是一个值。

在Java中， Math类中有一个random()方法，它返回一个介于0.0和1.0之间的double值。 在类Random有nextInt(int n) ，它返回一个随机的int值，取值范围为0 （包括）和n （不包括）。 我找不到一个方法，它返回两个数字之间的随机整数值。

我已经尝试了以下的事情，但我仍然有问题:(最小和最大的数字是最小的和最大的）。

解决scheme1：

 randomNum = minimum + (int)(Math.random() * maximum); 

问题：

randomNum可以大于maximum 。

解决scheme2：

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

问题：

randomNum可以小于minimum 。

我如何解决这些问题？

我也试过浏览档案，发现：

• 从1-5到1-7扩展一个随机范围
• 在整个范围内均匀生成随机数

但是我解决不了这个问题。

Answer 1

在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实例，如果使用不当，可能会造成混淆和错误。

然而，相反地，没有办法显式地设置种子，所以在testing或保存游戏状态或类似的情况下很难重现结果。 在这些情况下，可以使用下面所示的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 not get 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来完成任务时，不需要重新创build随机整数生成轮。

Answer 2

请注意，这种方法比nextInt方法更有偏见，效率更低， https : nextInt

完成这个的一个标准模式是：

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

Java Math库函数Math.random（）在[0,1)范围内生成一个double值。 注意这个范围不包括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)) 

Answer 3

使用：

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

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

Answer 4

使用：

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

Answer 5

你可以编辑你的第二个代码示例来：

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

Answer 6

在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方法的重载方法）。

如果你需要做多个单独的调用，你可以从stream中创build一个无限的基本迭代器：

 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值。

希望它有帮助！ 🙂

Answer 7

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

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

---

随机查看Random类的实现： Random

Answer 8

ThreadLocalRandom用于multithreading环境的java.util.Random类。 生成一个随机数是在每个线程中进行的。 所以我们通过减less冲突来获得更好的performance。

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

x，y – 区间例如（1,10）

Answer 9

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

为了更好的理解，请查看论坛postRandom Intervals（archive.org） 。

Answer 10

请原谅我的讲究，但大多数人提出的解决scheme，即min + rng.nextInt(max - min + 1))似乎是危险的，因为：

• rng.nextInt（n）不能达到Integer.MAX_VALUE。
• （最小 – 最小）可能会导致溢出，当min是负的。

万无一失的解决scheme将在[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; } 

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

Answer 11

我想知道是否有一个由Apache Commons Math库提供的随机数生成方法是否适合账单。

例如： RandomDataGenerator.nextInt或RandomDataGenerator.nextLong

Answer 12

让我们举一个例子。

假设我希望生成一个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); 

让我们来了解这个 …

用最高值初始化最大值，用最小值初始化最小值。

现在，我们需要确定可以获得多less个可能的值。 对于这个例子，这将是

5，6，7，8，9，10

所以，这个计数将是最大最小+ 1。

即10-5 + 1 = 6

随机数将产生一个0-5之间的数字。

即0,1,2,3,4,5

将最小值添加到随机数将产生

5，6，7，8，9，10

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

Answer 13

使用nextint（n）方法生成最小值和最大值的差值的随机数，然后将最小值添加到结果中：

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

Answer 14

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

Answer 15

尝试

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

Answer 16

这种方法可能方便使用：

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

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

Answer 17

在掷骰子的情况下，它将是1到6（不是0到6）之间的随机数，因此：

 face = 1 + randomNumbers.nextInt(6); 

Answer 18

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

Answer 19

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

你可以重用它作为hole类中的字段，也可以在同一个地方使用所有的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; } } 

Answer 20

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

或者看看Apache Commons的 RandomUtils。

Answer 21

只要使用随机类：

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

Answer 22

当你需要大量的随机数时，我不build议在API中使用Random类。 这只是一个太短的时间。 试试梅森扭转者 。 有一个Java实现 。

Answer 23

我在http://www.javapractices.com/topic/TopicAction.do?Id=62上find了这个例子：;

---

这个例子生成一个特定范围内的随机整数。

 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. 

Answer 24

如果你想尝试上面得票最多的答案，你可以简单地使用这个代码：

 public class Randomizer { public static int generate(int min,int max) { return min + (int)(Math.random() * ((max - min) + 1)); } public static void main(String[] args) { System.out.println(Randomizer.generate(0,10)); } } 

这只是干净和简单。

Answer 25

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

Answer 26

另一种select是使用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); 

Answer 27

 private static Random random = new Random(); public static int getRandomInt(int min, int max){ return random.nextInt(max - min + 1) + min; } 

要么

 public static int getRandomInt(Random random, int min, int max) { return random.nextInt(max - min + 1) + min; } 

Answer 28

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

Answer 29

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

这工作正常。

Answer 30

 import java.util.Random; public class RandomUtil { // Declare as class variable so that it is not re-seeded every call private static Random random = new Random(); /** * Returns a psuedo-random number between min and max (both inclusive) * @param min Minimim value * @param max Maximim value. Must be greater than min. * @return Integer between min and max (both inclusive) * @see java.util.Random#nextInt(int) */ public static int nextInt(int min, int max) { // nextInt is normally exclusive of the top value, // so add 1 to make it inclusive return random.nextInt((max - min) + 1) + min; } }