如何在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`.
在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 *Integer.MAX_VALUE - 1. * * @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来完成任务时，不需要重新发明随机整数生成轮。
请注意，这种方法比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值来完成此操作。
Min + (Math.random() * (Max - Min))
您现在将获得[Min,Max)范围内的值。 按照我们的例子，这意味着[5,10) ：
5 + (Math.random() * (10 - 5))
但是，这仍然不包括Max ，你得到的是双倍价值。 为了获得Max值，您需要在范围参数(Max - Min)加1，然后通过强制转换为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的随机数。
使用：
minimum + 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等效于multithreading环境的类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);
为了更好地理解，请查看论坛postRandom Intervals（archive.org） 。
请原谅我的挑剔，但大多数建议的解决方案，即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％或更高。
我想知道Apache Commons Math库提供的任何随机数生成方法是否符合要求。
例如： RandomDataGenerator.nextInt或RandomDataGenerator.nextLong
让我们举个例子。
假设我希望生成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);
让我们理解这一点 ……
使用最高值初始化max，使用最低值初始化min。
现在，我们需要确定可以获得多少可能的值。 对于这个例子，它将是：
5,6,7,8,9,10
因此，这将是最大 – 最小+ 1的计数。
即10 – 5 + 1 = 6
随机数将生成0-5之间的数字。
即0,1,2,3,4,5
将min值添加到随机数将产生：
5,6,7,8,9,10
因此，我们获得了所需的范围。
rand.nextInt((max+1) - min) + min;
这是一个有用的类，可以在包含/包含任意组合的范围内生成随机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; } }
使用nextint（n）方法生成min和max之差的随机数，然后将min number添加到结果中：
Random rn = new Random(); int result = rn.nextInt(max - min + 1) + min; System.out.println(result);
在滚动骰子的情况下，它将是1到6之间的随机数（不是0到6），因此：
face = 1 + randomNumbers.nextInt(6);
从Java 7开始，您不应再使用
Random。 对于大多数用途，选择的随机数生成器现在是ThreadLocalRandom。对于fork连接池和并行流，请使用
SplittableRandom。
约书亚布洛赫。 有效的Java。 第三版。
从Java 8开始
对于fork连接池和并行流，使用通常更快的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);
int random = minimum + Double.valueOf(Math.random()*(maximum-minimun)).intValue();
或者看一下Apache Commons的 RandomUtils。
这种方法可能很方便使用：
此方法将在提供的最小值和最大值之间返回一个随机数：
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; }
当您需要大量随机数时，我不推荐API中的Random类。 这个时期太短了。 试试Mersenne twister代替。 有一个Java实现 。
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); }
我发现这个例子生成随机数 ：
此示例生成特定范围内的随机整数。
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.
您可以在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);
这是一个简单的示例，显示如何从闭合[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; } }
只需使用Random类：
Random ran = new Random(); // Assumes max and min are non-negative. int randomInt = min + ran.nextInt(max - min + 1);
另一种选择是使用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 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)); } }
它干净而简单。
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; }
最好使用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;
这工作正常。