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

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

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

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

Java Math 库函数 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 ,您需要在范围参数(Max - Min)上加 1,然后通过强制转换为整数来截断小数部分。这可以通过以下方式完成:

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)

使用他们在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值和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执行的信息

Java 中Math.Random类基于 0。因此,如果您编写如下内容:

Random rand = new Random();
int x = rand.nextInt(10);

x将介于0-90-9之间(含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
  • min为负数时(max - min)可能导致溢出。

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