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


3499

如何生成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`.

当您需要大量随机数时,建议不要在API中使用Random类。周期太短了。请尝试使用梅森捻线机。有一个Java实现
raupach

1
发布新答案之前,请考虑该问题已经有65个以上的答案。请确保您的答案提供的信息不属于现有答案。
janniks

Answers:


3797

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完成任务时,就无需重新发明随机整数生成轮。


43
对于maxInteger.MAX_VALUE可能会溢出的呼叫,将导致java.lang.IllegalArgumentException。你可以尝试使用:randInt(0, Integer.MAX_VALUE)。另外,如果nextInt((max-min) + 1)返回最高值(我认为非常罕见),它不会再次溢出(假设min和max足够高)吗?如何处理这种情况?
丹尼尔(Daniel)

3
@MoisheLipsker一定是nextLong不能作为nextInteger的界限
mmm

13
ThreadLocalRandom在首次提出此问题后的2 1/2年,@ leventov 被添加到Java中。我一直坚决认为,对Random实例的管理不在问题范围之内。
格雷格案

6
在Android中,随机rand = new Random();
Webserveis

5
@Webserveis在示例的注释中解决。简短版本-不应为每次调用该函数= new Random(),否则在许多情况下结果都不会足够随机。
格雷格·凯斯

1421

请注意,此方法比https://stackoverflow.com/a/738651/360211nextInt方法更具偏见且效率较低

实现此目的的一种标准模式是:

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 + (Math.random() * (Max - Min))

您现在将获得范围内的值[Min,Max)。按照我们的示例,这意味着[5,10)

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

但是,这还不包括在内Max,您将获得双倍的价值。为了获得Max包含的值,您需要在范围参数中加1 (Max - Min),然后通过强制转换为int截断小数部分。这可以通过以下方式完成:

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

那里有它。范围内的随机整数值[Min,Max],或根据示例[5,10]

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

82
Sun文档明确指出,如果需要int而不是产生双精度数的Math.random(),则最好使用Random()。
莉莲·莫拉鲁

6
与nextInt方法相比,这实际上是有偏见的stackoverflow.com/a/738651/360211
weston

4
在这种情况下,“有偏见”是指在2 ^ 53次处决之后,平均一些人会有额外的占用。
Cephalopod

378

采用:

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

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



137

他们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();
    }
}

您也可以将其用于doublelong值。希望对您有所帮助!:)


1
我建议您只实例化randomIterator一次。参见格雷格·凯斯(Greg Case)对自己的回答的评论。
Naxos84 '18 -2-26

如果可以,您能否解释一下streamSize-此方法的第一个参数的意义是什么streamSize !=0。如果streamSize给定1/2 / n,有什么区别?
Erfan Ahmed

104

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

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

99

只需对您的第一个解决方案进行少量修改就可以了。

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

在此处查看更多实现 Random


对于最小值<=值<最大值,我对数学进行了相同的操作:randomNum =最小值+(int)(Math.random()*(maximum-minimum)); 但是演员表真的不怎么好看;)
AxelH

至少重复7年。
Maarten Bodewes,

70

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

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

xy-间隔,例如(1,10)


66

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将返回25nextInt( i.length )将返回范围之间的数字0-24。另一个选择与之Math.Random相同。

index = (int) Math.floor(Math.random() * i.length);

为了更好的理解,请查看论坛帖子Random Intervals(archive.org)


为wayBackMachine存档屏幕快照链接+1,您的答案仍然对获得带范围内的“随机”整数很有用。
Tapper7年

这让我感到困惑,为什么您将索引实例
化为0。– AjahnCharles

@CodeConfident index变量将不会影响随机数的结果。您可以选择以任何方式初始化它,而不必担心更改结果。希望这可以帮助。
马特R

确实...它完全没有使用。我会直接将其初始化为兰特:int index = rand.nextInt(i.Length);
AjahnCharles

还是根本没有。 int index; \n index = rand...如果一个人喜欢不同行的声明和赋值。一些编码标准比其他标准更严格(没有明显的目的)。
Mark Storer

49

原谅我过于挑剔,但是min + rng.nextInt(max - min + 1))由于以下事实,多数人提出的解决方案似乎很危险:

  • rng.nextInt(n)达不到Integer.MAX_VALUE
  • (max - min)min负数时可能导致溢出。

万无一失的解决方案将为min <= max[ Integer.MIN_VALUEInteger.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%或更高。


当差异= Integer.MAX_VALUE时为什么不引发IllegalArgumentException?然后,您就不需要while循环。
MP Korstanje'1

3
@mpkorstanje此实现旨在与min <= max的任何值一起使用,即使它们的差等于或大于MAX_VALUE。在这种情况下,运行循环直到成功是一种常见的模式,以确保分布均匀(如果随机性的基础是均匀的)。Random.nextInt(INT)做它时,内部参数不是2的功率
基督教Semrau

44

只需执行以下语句即可完成:

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

以下是其源代码

Randomizer.java

public class Randomizer {
    public static int generate(int min,int max) {
        return min + (int)(Math.random() * ((max - min) + 1));
    }
}

这只是干净和简单。


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

1
没错,@ MaartenBodewes。当我编写此答案时,上面获得最高票数的答案仍被编写为类似于算法的解决方案。现在,上面的解决方案已经发生了很大的变化,现在这个答案看起来像是在模仿。
亚伯卡莱霍

我真的不明白为什么这些基本的代码不是Java标准库的一部分。为什么我必须执行此操作?
Leevi L


31

让我们举个例子。

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

让我们了解一下 ...

用最大值初始化最大值,用最小值初始化最小值。

现在,我们需要确定可以获取多少个可能的值。对于此示例,它将是:

5、6、7、8、9、10

因此,此计数为max-min + 1。

即10-5 + 1 = 6

随机数将生成一个介于0-5之间的数字。

即0、1、2、3、4、5

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

5、6、7、8、9、10

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



26

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

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

26

我用这个:

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

如果需要,可以将其转换为整数。


此函数一遍又一遍地产生相同的数字。以我
为例

失败:您有一个函数需要先加倍再执行+ 1?这当然违背了最小惊讶原则。如果使用min = 0.1和max = 0.2会发生什么?
Maarten Bodewes

@sokras方法调用new Random(检查JavaDoc):“创建一个新的随机数生成器。此构造函数将随机数生成器的种子设置为一个很可能与该构造函数的其他调用不同的值。” 很可能只涉及使用当前时间作为种子。如果该时间使用毫秒,则当前计算机的速度足以生成相同的数字。但是除了2147483647是Integer.MAX_VALUE; 输出显然取决于您尚未指定的输入。
Maarten Bodewes

终于找到了一个有效的方法
-Jency

23

从Java 7开始,您不应再使用Random。对于大多数用途,现在选择的随机数生成器为 ThreadLocalRandom

对于派生连接池和并行流,请使用SplittableRandom

约书亚·布洛赫(Joshua Bloch)。有效的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);

该示例中是否包含一个原因.parallel()?在我看来,生成100个随机数将显得微不足道,无法保证并行性。
Johnbot '18年

@Johnbot感谢您的评论,您是对的。但是,主要原因是要显示一个API(当然,智能路径是在使用parallel处理之前测量性能)。顺便说一下,对于1_000_000元素数组,该parallel版本在我的机器上比顺序版本快2倍。
Oleksandr Pyrohov '18

21

只需使用Random类:

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

8
我看不到这里没有任何其他较早的帖子中发布过的新内容。
Maarten Bodewes

20

使用此方法可能很方便:

此方法将在提供的最小值和最大值之间返回一个随机数:

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

// Since the random number is between the min and max values, simply add 1。为什么?分钟不算数吗?通常范围是[min,max),其中包括min,但不包括max。答案错误,投了反对票。
Maarten Bodewes

添加@MaartenBodewes +1是因为getRandomNumberBetween生成一个随机数,不包括所提供的端点。
卢克·泰勒

1
该数字的结果min + 1将是另一个数字的两倍getRandomNumberBetween

19

如果掷骰子,则它是1到6之间的随机数(而不是0到6),因此:

face = 1 + randomNumbers.nextInt(6);

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

或查看Apache Commons中的 RandomUtils 。


这很有用,但是要提防一个小缺陷:方法签名类似于:nextDouble(double startInclusive,double endInclusive),但是如果您查看方法内部,则endInclusive实际上应该是endExclusive。
zakmck,2015年

Double.valueOf(Math.random()*(maximum-minimun)).intValue()是一种令人困惑(且效率低下)的说法(int)(Math.random()*(maximum-minimun))……
Holger

最小返回最小值+ Double.valueOf(Math.random()*(maximum-minimum))。intValue()的拼写不匹配
里希克虚什米什拉16/12/26

18

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

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

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

这为您提供了一个介于1(含)和11(不含)之间的随机数,因此请通过添加1来初始化upperBound值。例如,如果要生成介于1到10之间的随机数,请使用11而不是初始化InitialBound数10。


18

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

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

16

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

16

我发现此示例生成随机数


本示例生成特定范围内的随机整数。

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.

14

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

1
这不是很好,因为如果它在同一毫秒中执行,那么您将获得相同的数字,则需要将rand初始化和setSeet放在方法之外。
maraca

是的,您需要种子,但是要使用SecureRandom。
grep 2015年

很抱歉,但是拒绝更改请求的人没有Java编程的提示。这是一个很好的建议,但是这是错误的,因为如果在同一毫秒中执行,它将给出相同的数字,而不是随机的。
maraca

找不到正确的解决方案,没有多少人知道静态初始化程序块……这就是设置种子的方式:1:private static int SecureRandom rand = new SecureRandom();2:static {3:rand.setSeed(...);4:}
maraca 2015年

5
绝对不需要播种SecureRandom,它将由系统播种。直接调用setSeed是非常危险的,它可能用日期替换(实际上是随机的)种子。但这肯定不会导致SecureRandom,因为任何人都可以猜测时间,然后尝试SecureRandom使用该信息来播种自己的实例。
Maarten Bodewes

13

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

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.