如何在特定范围内生成随机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`.
答案 0 :(得分：3564)
在 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来完成任务时，不需要重新发明随机整数生成轮。
答案 1 :(得分：1381)
请注意，与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 + (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))
答案 2 :(得分：336)
使用：
Random ran = new Random();
int x = ran.nextInt(6) + 5;
整数x现在是可能结果为5-10的随机数。
答案 3 :(得分：142)
使用：
minimum + rn.nextInt(maxValue - minvalue + 1)
答案 4 :(得分：115)
使用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值执行此操作。
希望它有所帮助！ ：）
答案 5 :(得分：100)
您可以将第二个代码示例编辑为：
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
答案 6 :(得分：97)
只需对您的第一个解决方案进行一点修改即可。
Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);
请点击此处查看Random
答案 7 :(得分：62)
ThreadLocalRandom等效于多线程环境的类java.util.Random。在每个线程中本地执行生成随机数。因此，通过减少冲突，我们可以获得更好的表现。
int rand = ThreadLocalRandom.current().nextInt(x,y);
x，y - 间隔例如（1,10）
答案 8 :(得分：61)
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) 。
答案 9 :(得分：48)
请原谅我的挑剔，但多数人建议的解决方案，即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％或更高。
答案 10 :(得分：33)
我想知道Apache Commons Math库提供的任何随机数生成方法是否符合要求。
答案 11 :(得分：31)
可以通过简单地做声明来完成：
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));
}
}
它干净简单。
答案 12 :(得分：30)
让我们举个例子。
假设我希望在 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
因此我们获得了所需的范围。
答案 13 :(得分：27)
rand.nextInt((max+1) - min) + min;
答案 14 :(得分：22)
使用nextint(n)方法生成最小值和最大值之差的随机数，然后在结果中添加最小数字：
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
答案 15 :(得分：21)
从Java 7开始，您不应再使用
Random。对于大多数用途， 现在选择随机数发生器ThreadLocalRandom。
对于fork join pool和parallel 流，使用SplittableRandom。
Joshua Bloch。有效的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);
答案 16 :(得分：19)
这种方法可能很方便使用：
此方法将在 之间返回一个随机数 提供的最小值和最大值：
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;
}
答案 17 :(得分：19)
这是一个有用的类，可以在包含/包含任意组合的范围内生成随机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;
}
}
答案 18 :(得分：19)
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
或者查看来自Apache Commons的RandomUtils。
答案 19 :(得分：19)
如果掷骰子，它将是1到6之间的随机数（不是0到6），所以：
face = 1 + randomNumbers.nextInt(6);
答案 20 :(得分：18)
要在两个数字＆＃34;之间生成随机数＆＃34;，请使用以下代码：
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
这为您提供1（包括）和11（不包括）之间的随机数，因此通过添加1来初始化upperBound值。例如，如果要生成1到10之间的随机数，则使用以下方法初始化upperBound数： 11而不是10。
答案 21 :(得分：17)
我找到了这个例子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.
答案 22 :(得分：17)
You can achieve that concisely in 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);
答案 23 :(得分：17)
只需使用Random类：
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
答案 24 :(得分：16)
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);
}
答案 25 :(得分：16)
当您需要大量随机数时，我不推荐API中的Random类。这个时期太短了。请尝试使用Mersenne twister。有a Java implementation。
答案 26 :(得分：15)
另一种选择是使用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);
// ...
}
答案 27 :(得分：14)
以下是一个简单的示例，展示了如何从关闭的[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;
}
}
答案 28 :(得分：13)
最好使用SecureRandom而不仅仅是随机。
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;
}
答案 29 :(得分：12)
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
答案 30 :(得分：12)
rand.nextInt((max+1) - min) + min;
这很好用。
答案 31 :(得分：9)
我用这个：
/**
* @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;
}
如果需要，可以将其强制转换为整数。
答案 32 :(得分：8)
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;
}
}
答案 33 :(得分：7)
您可以这样做：
import java.awt.*;
import java.io.*;
import java.util.*;
import java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
答案 34 :(得分：7)
您可以使用此代码段来解决您的问题：
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
使用myRandomNumber（它会给你一个范围内的数字）。
答案 35 :(得分：6)
我将简单说明问题提供的解决方案有什么问题以及错误原因。
解决方案1：
randomNum = minimum + (int)(Math.random()*maximum);
问题：为randomNum分配的值大于最大值。
说明：假设我们的最小值为5，最大值为10. Math.random()大于0.6的任何值都会使表达式计算为6或更大，而添加5表示大于10（最大值） 。问题是你将随机数乘以最大值（产生一个几乎与最大值一样大的数字），然后加上最小值。除非最小值为1，否则它是不正确的。您必须切换到，如其他答案中所述
randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))
+1是因为Math.random()永远不会返回1.0。
解决方案2：
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
这里的问题是，如果第一项小于0，'％'可能会返回一个负数。由于rn.nextInt()返回负值的概率约为50％，因此您也无法得到预期结果。< / p>
然而，这几乎是完美的。你只需要看一下Javadoc，nextInt(int n)。使用该方法，执行
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum = minimum + i;
也会返回所需的结果。
答案 36 :(得分：6)
使用Java 8 IntStream和Collections.shuffle的不同方法
import java.util.stream.IntStream;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
Scala中的等效内容
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
答案 37 :(得分：5)
您可以使用
RandomStringUtils.randomNumeric(int count)
方法也来自apache commons。
答案 38 :(得分：5)
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
答案 39 :(得分：4)
我想通过使用以下方法将生成的随机数线性归一化到所需范围。设x为随机数，让a和b为所需标准化数字的最小和最大范围。
然后下面是一个非常简单的代码片段，用于测试线性映射产生的范围。
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
答案 40 :(得分：4)
在尝试1 中进行以下更改即可完成工作-
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
检查this以获取工作代码。
答案 41 :(得分：4)
import java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
您也可以使用
import java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
但是，这个类在多线程环境中表现不佳。
答案 42 :(得分：4)
我只是使用Math.random（）生成一个随机数，然后乘以一个大数字，比方说10000.所以，我得到一个介于0到10,000之间的数字并调用这个数字i。现在，如果我需要（x，y）之间的数字，那么请执行以下操作：
i = x + (i % (y - x));
因此，所有i都是x和y之间的数字。
要删除评论中指出的偏见，而不是将其乘以10000（或大数字），请将其乘以（y-x）。
答案 43 :(得分：3)
假设您希望范围在0-9之间，0最小，9最大。以下功能将打印介于0和9之间的任何内容。对于所有范围，它都是相同的。
public static void main(String[] args) {
int b = randomNumberRange(0, 9);
int d = randomNumberRange (100, 200);
System.out.println("value of b is " + b);
System.out.println("value of d is " + d);
}
public static int randomNumberRange(int min, int max) {
int n = (max + 1 - min) + min;
return (int) (Math.random() * n);
}
答案 44 :(得分：3)
使用Apache Lang3 Commons
Integer.parseInt(RandomStringUtils.randomNumeric(6, 6));
最小值100000至最大值999999
答案 45 :(得分：3)
以下是使用Random和forEach
的另一个示例int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
答案 46 :(得分：3)
您可以使用Random类生成随机数，然后使用.nextInt（maxNumber）生成随机数。 maxNumber是生成随机数时所需的最大数字。请记住，Random类为您提供数字0到maxNumber-1。
Random r = new Random();
int i = r.nextInt();
另一种方法是使用Math.Random（）类，学校中的许多类要求您使用它，因为它更有效并且您不必声明新的Random对象。要使用Math.Random（）获取随机数，请键入：
Math.random() * (max - min) + min;
答案 47 :(得分：3)
以下代码生成100,000到900,000之间的随机数。此代码将生成六位数值。我正在使用此代码生成一个六位数的OTP。
使用import java.util.Random来使用此随机方法。
import java.util.Random;
// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
答案 48 :(得分：3)
我的一位朋友今天在大学里问了我同样的问题（他的要求是生成一个介于1和-1之间的随机数）。所以我写了这个，到目前为止我的测试工作正常。理想情况下，有很多方法可以在给定范围的情况下生成随机数。试试这个：
功能：
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(rand-1);
float highRand = (float) Math.ceil(rand+1);
float genRand = (highRange-lowRange)*((rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
执行如下：
System.out.println( getRandomNumberBetween(1,-1));
答案 49 :(得分：3)
我认为这段代码适合它。请试试这个：
import java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
答案 50 :(得分：3)
如果您已使用Commons Lang API 2.x或最新版本，那么有一个用于生成随机数的类RandomUtils。
public static int nextInt(int n)
从Math.random（）序列返回伪随机，在0（包括）和指定值（不包括）之间均匀分布的int值。
参数： n - 指定的独占最大值
int random = RandomUtils.nextInt(1000000);
注意：在RandomUtils中有许多随机数生成方法
答案 51 :(得分：3)
我创建了一个方法来获取给定范围内的唯一整数。
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
答案 52 :(得分：3)
这将生成随机数列表，范围（最小 - 最大），无重复。
generateRandomListNoDuplicate(1000, 8000, 500);
添加此方法。
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
希望这会对你有所帮助。
答案 53 :(得分：2)
int func(int max, int min){
int range = max - min + 1;
// Math.random() function will return a random no between [0.0,1.0).
int res = (int) ( Math.random()*range)+min;
return res;
}
答案 54 :(得分：2)
您可以使用以下方式进行操作
int range = 10;
int min = 5
Random r = new Random();
int = r.nextInt(range) + min;
答案 55 :(得分：2)
在a和b之间生成n个随机数的简单方法 例如a = 90，b = 100，n = 20
Random r = new Random();
for(int i =0; i<20; i++){
System.out.println(r.ints(90, 100).iterator().nextInt());
}
r.ints()会返回IntStream并有几个有用的方法，请查看其API。
答案 56 :(得分：2)
将java.util用于一般随机使用。
您可以定义最小和最大范围来获得这些结果。
Random rand=new Random();
rand.nextInt((max+1) - min) + min;
答案 57 :(得分：2)
public static void main(String[] args) {
Random ran = new Random();
int min, max;
Scanner sc = new Scanner(System.in);
System.out.println("Enter min range:");
min = sc.nextInt();
System.out.println("Enter max range:");
max = sc.nextInt();
int num = ran.nextInt(min);
int num1 = ran.nextInt(max);
System.out.println("Random Number between given range is " + num1);
}
答案 58 :(得分：2)
[min..max]范围内的随机数：
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
答案 59 :(得分：2)
上述大多数建议都不考虑溢出＆＃39;，例如：min = Integer.MIN_VALUE，max = 100.到目前为止，我所采用的正确方法之一是：
final long mod = max- min + 1L;
final int next = (int) (Math.abs(rand.nextLong() % mod) + min);
答案 60 :(得分：2)
https://sourceforge.net/projects/stochunit/有一个库用于处理范围的选择。
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
它有边缘包含/排除。
答案 61 :(得分：2)
尝试使用org.apache.commons.lang.RandomStringUtils课程。是的，它有时会相邻地给出重复的数字，但它会给出5到15之间的值：
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
答案 62 :(得分：1)
使用Java 8 Streams，
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
在此示例中，它会从1-Randombound生成数字。
答案 63 :(得分：1)
使用math.random()并在if语句中设置要求。最简单，最简单，最快的方法
答案 64 :(得分：1)
为了避免重复多次说过的内容，我通过使用扩展类 Random 的 SecureRandom 类为那些需要密码学上更强大的伪随机数生成器的人展示了一种替代方法。从 source 可以阅读：
这个类提供了一个加密强的随机数生成器 (RNG)。 加密强随机数最低限度地符合 使用 FIPS 中指定的统计随机数生成器测试 140-2，加密模块的安全要求，第 4.9.1 节。 此外，SecureRandom 必须产生非确定性输出。 因此，任何传递给 SecureRandom 对象的种子材料都必须是 不可预测，所有 SecureRandom 输出序列必须是 加密强，如 RFC 1750: Randomness 中所述 安全建议。
调用者通过无参数获取 SecureRandom 实例 构造函数或 getInstance 方法之一：
SecureRandom random = new SecureRandom();
许多 SecureRandom 实现都采用伪随机数生成器的形式 (PRNG)，这意味着他们使用确定性算法来生成 来自真随机种子的伪随机序列。其他实现 可能会产生真正的随机数，而其他人可能会使用组合 两种技术。
生成一个介于 min 和 max 之间的随机数：
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
对于给定的 min（包含）和 max（不包含）值：
return min + secureRandom.nextInt((max - min));
运行代码示例：
public class Main {
public static int generate(SecureRandom secureRandom, int min, int max) {
return min + secureRandom.nextInt((max - min) + 1);
}
public static void main(String[] arg) {
SecureRandom random = new SecureRandom();
System.out.println(generate(random, 0, 2 ));
}
}
stackoverflow、baeldung、geeksforgeeks 等源提供了 Random 和 SecureRandom 类之间的比较。
从 baeldung 可以读到：
<块引用>最常见的使用 SecureRandom 的方法是生成 int、long、 浮点、双精度或布尔值：
int randomInt = secureRandom.nextInt();
long randomLong = secureRandom.nextLong();
float randomFloat = secureRandom.nextFloat();
double randomDouble = secureRandom.nextDouble();
boolean randomBoolean = secureRandom.nextBoolean();
为了生成 int 值，我们可以传递一个上限作为参数：
int randomInt = secureRandom.nextInt(upperBound);
此外，我们可以为 int、double 和 long 生成值流：
IntStream randomIntStream = secureRandom.ints();
LongStream randomLongStream = secureRandom.longs();
DoubleStream randomDoubleStream = secureRandom.doubles();
对于所有流，我们可以明确设置流大小：
IntStream intStream = secureRandom.ints(streamSize);
该课程提供了超出本问题范围的其他几个选项（例如，选择基础随机数生成器）。
答案 65 :(得分：0)
Random rng = new Random();
int min = 3;
int max = 11;
int upperBound = max - min + 1; // upper bound is exclusive, so +1
int num = min + rng.nextInt(upperBound);
System.out.println(num);
答案 66 :(得分：0)
这是非常简单的代码，它生成介于1和变量maximum之间的随机数，然后确定该随机数是否小于minimum。
如果答案是肯定的，则将minimum添加到随机数。然后返回数字。
public static int random(int minimum, int maximum) {
int i = (int) (Math.random() * maximum);
if (i < minimum) {
return i + minimum;
} else {
return i;
}
}
答案 67 :(得分：0)
import java.util.Random;
public class Main
{
public static void main(String[] args) {
Random rand = new Random();
System.out.printf("%04d%n", rand.nextInt(10000));
}
}
答案 68 :(得分：0)
这是一个函数，该函数将根据要求由 lowerBoundIncluded 和 upperBoundIncluded 定义的范围内恰好返回一个整数随机数 user42155
SplittableRandom splittableRandom = new SplittableRandom();
BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
-> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
randomInt.apply( …, … ); // gets the random number
答案 69 :(得分：0)
可以使用以下代码：
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
答案 70 :(得分：0)
下面是一个示例类，显示了如何生成特定范围内的随机整数。将所需的任何值作为最大值分配给变量“ max”，并将所需的任何值作为最小值分配给变量“ min”。
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max = 10;
int min = 5;
int x;
x = r.nextInt(max) + min;
System.out.println(x);
}
}
答案 71 :(得分：-1)
public static int getRandomNumberInts(int min, int max){
Random random = new Random();
return random.ints(min,(max+1)).findFirst().getAsInt();
}
我们可以尝试使用Java 8中新的random.ints函数来解决它。