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

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

请参阅相关的JavaDoc.实际上,java.util.Random类通常比java.lang.Math.random()更可取.

特别是,当标准库中有一个简单的API来完成任务时,不需要重新发明随机整数生成轮.

• 对于`max`值为`Integer.MAX_VALUE`的调用,可能会溢出,导致`java.lang.IllegalArgumentException`.您可以尝试:`randInt(0,Integer.MAX_VALUE)`.另外,如果`nextInt((max-min)+ 1)`返回最高值(非常罕见,我认为)不会再次溢出(假设min和max足够高)？如何应对这种情况？
• @leventov`ThreadLocalRandom`在第一次提出这个问题后的2年半里被添加到Java中.我一直坚持认为Random实例的管理超出了问题的范围.
• 在Android中随机rand = new Random();
• @Webserveis这在示例中的注释中解决.简短版本 - 你不应该为每次调用函数使用= new Random(),否则你的结果在很多情况下都不会是随机的.
• @MoisheLipsker必须是nextLong不将bound作为nextInteger
• @ChitKhine不是每次调用该函数.当生成连续的随机数时,随机引擎下的RNG算法运行良好(足以用于非加密应用).但是,如果在每次调用时重新创建Random实例,这意味着您将根据每次选择的种子获得"随机"数字而不是正确的RNG - 通常这取决于系统时钟.这可以给出明显的非随机结果.相反,您应该考虑在方法范围之外实例化Random实例.示例代码尝试解决此问题.
• @AbhishekSingh注释试图解决这个问题,但更详细地说:nextInt(N)返回一个从0到N-1的数字,即它永远不会返回N. 在这种情况下,我们希望在可能的值范围中包含N,因此我们添加一个:nextInt(N + 1)=>返回0到N范围内的数字,包括0和N
• 祝你好运测试使用ThreadLocalRandom的类.

请注意,这种方法比nextInt方法更有偏见且效率更低,/sf/answers/51705601/

实现这一目标的一个标准模式是:

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

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

该爪哇数学库函数的Math.random()生成的范围内的双值[0,1).请注意,此范围不包括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包含的值,您需要在range参数中添加1 (Max - Min),然后通过强制转换为int来截断小数部分.这是通过以下方式完成

你有它.范围内的随机整数值[Min,Max],或者根据示例[5,10]:

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

• Sun文档明确指出,如果需要int而不是生成double的Math.random(),最好使用Random().
• 与nextInt方法相比,这实际上是有偏见的http://stackoverflow.com/a/738651/360211
• 在这种情况下，“有偏见”是指在2 ^ 53次处决之后，平均一些人会有额外的占用。

使用:

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

整数x现在是具有可能结果的随机数5-10.

使用:

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价值观做.

希望能帮助到你!:)

• 我建议您只将 randomIterator 实例化一次。请参阅 Greg Case 对他自己的回答的评论。

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

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

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

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

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

x,y - 间隔例如(1,10)

请原谅我的挑剔,但多数人建议的解决方案,即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%或更高.

• @mpkorstanje此实现旨在处理min <= max的任何值,即使它们的差值等于或甚至大于MAX_VALUE.在这种情况下,运行循环直到成功是一种常见模式,以保证均匀分布(如果潜在的随机源是均匀的).当参数不是2的幂时,Random.nextInt(int)在内部执行.

如果您想尝试上述投票最多的答案,您可以使用以下代码:

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

它干净而简单.

• 这本可以是其他示例的编辑，现在它只是声誉的公然复制。指出“票数最多的答案”也不是很直接，可以改变。

我想知道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);

让我们理解这个 ......

现在,我们需要确定可以获得多少可能的值.对于这个例子,它将是:

因此,这将是最大 - 最小+ 1的计数.

随机数将生成0-5之间的数字.

将min值添加到随机数将产生:

因此,我们获得了所需的范围.

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

使用nextint(n)方法生成min和max之差的随机数,然后将min number添加到结果中:

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

约书亚布洛赫.有效的Java.第三版.

从Java 8开始

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

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

或者看一下Apache Commons的 RandomUtils .

在掷骰子的情况下,它将是1到6之间的随机数(不是0到6),因此:

face = 1 + randomNumbers.nextInt(6);

这是一个有用的类,可以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;
}
}

要在"两个数字之间"生成随机数,请使用以下代码:

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.

只需使用Random类:

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 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 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);

当您需要大量随机数时,我不推荐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);
}

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

我用这个:

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

如果需要,可以将其强制转换为整数.

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

• 绝对没有必要播种`SecureRandom`,它将由系统播种.直接调用`setSeed`是非常危险的,它可以用日期替换(真正随机的)种子.这肯定会导致`SecureRandom`,因为任何人都可以猜测时间并尝试使用该信息播种自己的`SecureRandom`实例.

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

这工作正常.

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

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

您可以使用此代码段来解决您的问题:

Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;

使用myRandomNumber(它会给你一个范围内的数字).

你可以这样做:

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

我将简单地说明问题提供的解决方案有什么问题以及错误原因.

解决方案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%的几率,你也不会得到预期的结果.

然而,这几乎是完美的.你只需要看一下Javadoc,nextInt(int n).用这种方法,做

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

也会返回所需的结果.

使用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)
}

可以使用以下代码：

ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)

• There have been multiple answers that already suggested `ThreadLocalRandom`. If a question has been protected then please take extra care not to duplicate answers.

我正在考虑使用以下方法将生成的随机数线性归一化为所需范围。让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);
}

你可以用

RandomStringUtils.randomNumeric(int count)

方法也来自apache commons.

Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;

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

但是，此类在多线程环境中表现不佳。