如何在特定范围内生成随机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);
见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来完成任务时,不需要重新发明随机整数生成轮。
请原谅我的挑剔,但多数人提出的解决方案,即min + rng.nextInt(max - min + 1))
,似乎是危险的,因为:
rng.nextInt(n)
无法到达Integer.MAX_VALUE
。(max - min)
为负时,min
可能会导致溢出。一个万无一失的解决方案将为[min <= max
,Integer.MIN_VALUE
]内的任何Integer.MAX_VALUE
返回正确的结果。考虑以下天真的实现:
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库提供的任何随机数生成方法是否适合该法案。
只需执行以下语句即可完成:
Randomizer.generate(0,10); //min of zero, max of ten
以下是其源代码
public class Randomizer
{
public static int generate(int min,int max)
{
return min + (int)(Math.random() * ((max - min) + 1));
}
}
它干净而简单。
让我们举个例子。
假设我希望生成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;
使用nextint(n)方法生成最小值和最大值之差的随机数,然后在结果中添加最小数:
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
从Java 7开始,您不应再使用
Random
。对于大多数用途,选择的随机数生成器现在是ThreadLocalRandom
。 对于fork连接池和并行流,请使用SplittableRandom
。
约书亚布洛赫。有效的Java。第三版。
对于fork连接池和并行流,使用通常更快的SplittableRandom
,与Random
相比具有更好的统计独立性和均匀性。
生成int
范围内的随机[0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
生成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);
这种方法可能很方便使用:
此方法将在提供的最小值和最大值之间返回一个随机数:
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;
}
这是一个有用的类,可以在包含/包含任意组合的范围内生成随机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;
}
}
在掷骰子的情况下,它将是1到6之间的随机数(不是0到6),因此:
face = 1 + randomNumbers.nextInt(6);
请注意,这种方法比nextInt
方法https://stackoverflow.com/a/738651/360211更有偏见且效率更低
实现这一目标的一个标准模式是:
Min + (int)(Math.random() * ((Max - Min) + 1))
Java数学库函数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 r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
这将为您提供1(包括)和11(不包括)之间的随机数,因此通过添加1来初始化upperBound值。例如,如果要生成1到10之间的随机数,则使用11而不是11来初始化upperBound数。 10。
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
或者看看Apache Commons的RandomUtils。
您可以在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);
我发现这个例子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.
只需使用Random类:
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
当您需要大量随机数时,我不推荐API中的Random类。这个时期太短了。请尝试使用Mersenne twister。有a Java implementation。
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);
}
另一种选择是使用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);
// ...
}
这是一个简单的示例,显示如何从封闭的[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;
}
使用:
Random ran = new Random();
int x = ran.nextInt(6) + 5;
整数x
现在是具有5-10
可能结果的随机数。
rand.nextInt((max+1) - min) + min;
这工作正常。
使用:
minimum + rn.nextInt(maxValue - minvalue + 1)
随着java-8他们在ints(int randomNumberOrigin, int randomNumberBound)
类中引入了Random
方法。
例如,如果要在[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)
Math.Random
的Java类是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)。