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

How do I generate a random int value in a specific range?

如何在特定范围内生成一个随机整型值?

I have tried the following, but those do not work:

我试过以下方法，但都没用:

Attempt 1:

尝试1:

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

Attempt 2:

尝试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`.

59 个解决方案

#1

In Java 1.7 or later, the standard way to do this is as follows:

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

See the relevant JavaDoc. This approach has the advantage of not needing to explicitly initialize a java.util.Random instance, which can be a source of confusion and error if used inappropriately.

看到相关的JavaDoc。这种方法的优点是不需要显式地初始化java.util。随机实例，如果使用不当，可能会造成混乱和错误。

However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.

然而，相反地，没有办法显式地设置种子，因此很难在诸如测试或保存游戏状态或类似的情况下重现结果。在这些情况下，可以使用下面所示的java前1.7技术。

Before Java 1.7, the standard way to do this is as follows:

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

See the relevant JavaDoc. In practice, the java.util.Random class is often preferable to java.lang.Math.random().

看到相关的JavaDoc。在实践中,java.util。Random类通常比java.lang.Math.random()更可取。

In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.

特别是，当标准库中有一个简单的API来完成这个任务时，不需要重新创建随机整数生成轮。

#2

Note that this approach is more biased and less efficient than a nextInt approach, https://*.com/a/738651/360211

注意，这种方法比nextInt方法(https://*.com/a/738651/360211)更有偏见，效率也更低

One standard pattern for accomplishing this is:

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

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

The Java Math library function Math.random() generates a double value in the range [0,1). Notice this range does not include the 1.

Java数学库函数Math.random()在范围[0,1]中生成一个双值。注意，这个范围不包括1。

In order to get a specific range of values first, you need to multiply by the magnitude of the range of values you want covered.

为了首先获得特定的值范围，您需要将所覆盖的值范围的大小相乘。

Math.random() * ( Max - Min )

This returns a value in the range [0,Max-Min), where 'Max-Min' is not included.

这将返回在[0,Max-Min]范围内的值，其中不包括'Max-Min'。

For example, if you want [5,10], you need to cover five integer values so you use

例如，如果您想要[5,10]，您需要覆盖五个整数值，以便使用

Math.random() * 5

This would return a value in the range [0,5), where 5 is not included.

这将返回范围[0,5]中的值，其中不包括5。

Now you need to shift this range up to the range that you are targeting. You do this by adding the Min value.

现在你需要把这个范围转移到你的目标范围。通过增加最小值来实现这一点。

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

You now will get a value in the range [Min,Max). Following our example, that means [5,10):

现在你会得到范围内的值[最小值，最大值]。以我们为例，这意味着[5,10]:

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

But, this still doesn't include Max and you are getting a double value. In order to get the Max value included, you need to add 1 to your range parameter (Max - Min) and then truncate the decimal part by casting to an int. This is accomplished via:

但是，这个仍然不包含Max你得到了一个双重值。为了得到包含的最大值，您需要在您的范围参数(Max - Min)中添加1，然后通过插入到int来截断小数部分。

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

And there you have it. A random integer value in the range [Min,Max], or per the example [5,10]:

这就是它。范围内的一个随机整数值[Min,Max]，或每个例子[5,10]:

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

#3

Use:

使用:

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

The integer x is now the random number that has a possible outcome of 5-10.

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

#4

Use:

使用:

minimum + rn.nextInt(maxValue - minvalue + 1)

#5

With java-8 they introduced the method ints(int randomNumberOrigin, int randomNumberBound) in the Random class.

在java-8中，他们在随机类中引入了方法int (int randomNumberOrigin, int randomNumberBound)。

For example if you want to generate five random integers (or a single one) in the range [0, 10], just do:

例如，如果您想在[0,10]范围内生成5个随机整数(或单个整数)，只需:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

The first parameter indicates just the size of the IntStream generated (which is the overloaded method of the one that produces an unlimited IntStream).

第一个参数仅指示生成的IntStream的大小(它是生成无限IntStream的重载方法)。

If you need to do multiple separate calls, you can create an infinite primitive iterator from the stream:

如果需要进行多个独立调用，可以从流中创建一个无限的原始迭代器:

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

You can also do it for double and long values.

你也可以做双倍和长的数值。

Hope it helps! :)

希望它可以帮助!:)

#6

You can edit your second code example to:

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

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

#7

Just a small modification of your first solution would suffice.

只要稍微修改一下您的第一个解决方案就足够了。

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

---

See more here for implementation of Random

这里更多的是为了实现随机。

#8

ThreadLocalRandom equivalent of class java.util.Random for multithreaded environment. Generating a random number is carried out locally in each of the threads. So we have a better performance by reducing the conflicts.

类java.util的ThreadLocalRandom等价。随机对多线程环境。在每个线程中本地生成随机数。通过减少冲突，我们有更好的表现。

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

x,y - intervals e.g. (1,10)

x,y -区间(1,10)

#9

The Math.Random class in Java is 0-based. So, if you write something like this:

的数学。Java中的Random类是基于0的。如果你这样写:

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

x will be between 0-9 inclusive.

x在0-9之间。

So, given the following array of 25 items, the code to generate a random number between 0 (the base of the array) and array.length would be:

因此，给定以下包含25项的数组，生成0(数组的基)和数组之间随机数的代码。长度是:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

Since i.length will return 25, the nextInt( i.length ) will return a number between the range of 0-24. The other option is going with Math.Random which works in the same way.

因为我。长度将返回25。长度)将返回0-24之间的数值。另一个选择是数学。用同样的方法。

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

For a better understanding, check out forum post Random Intervals (archive.org).

为了更好的理解，请查看论坛发布的随机间隔(archive.org)。

#10

Forgive me for being fastidious, but the solution suggested by the majority, i.e., min + rng.nextInt(max - min + 1)), seems perilous due to the fact that:

请原谅我过于挑剔，但是大多数人提出的解决办法是……分钟+提高。nextInt(max - min + 1)似乎很危险，因为以下事实:

• rng.nextInt(n) cannot reach Integer.MAX_VALUE.
• rng.nextInt(n)不能达到Integer.MAX_VALUE。
• (max - min) may cause overflow when min is negative.
• (最大值-最小值)当最小值为负值时可能会导致溢出。

A foolproof solution would return correct results for any min <= max within [Integer.MIN_VALUE, Integer.MAX_VALUE]. Consider the following naive implementation:

一个简单的解决方案将返回在[Integer]内的任何min <= max的正确结果。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;
}

Although inefficient, note that the probability of success in the while loop will always be 50% or higher.

尽管效率不高，但请注意while循环中成功的概率总是50%或更高。

#11

I wonder if any of the random number generating methods provided by an Apache Commons Math library would fit the bill.

我想知道Apache Commons Math库提供的任何随机数生成方法是否适用。

For example: RandomDataGenerator.nextInt or RandomDataGenerator.nextLong

例如:RandomDataGenerator。nextInt或RandomDataGenerator.nextLong

#12

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

#13

Let us take an example.

让我们举个例子。

Suppose I wish to generate a number between 5-10:

假设我想生成一个介于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);

Let us understand this...

让我们明白这一点……

Initialize max with highest value and min with the lowest value.

用最大值初始化max，用最小值初始化min。

Now, we need to determine how many possible values can be obtained. For this example, it would be:

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

5, 6, 7, 8, 9, 10

5 6 7 8 9 10

So, count of this would be max - min + 1.

所以这个的计数就是最大值-最小值+ 1。

i.e. 10 - 5 + 1 = 6

即10 - 5 + 1 = 6

The random number will generate a number between 0-5.

随机数将在0-5之间生成一个数字。

i.e. 0, 1, 2, 3, 4, 5

即0 1 2 3 4 5。

Adding the min value to the random number would produce:

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

5, 6, 7, 8, 9, 10

5 6 7 8 9 10

Hence we obtain the desired range.

因此我们得到了期望的范围。

#14

Generate a random number for the difference of min and max by using the nextint(n) method and then add min number to the result:

使用nextint(n)方法生成最小和最大差的随机数，然后在结果中添加最小值:

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

#15

Here's a helpful class to generate random ints in a range with any combination of inclusive/exclusive bounds:

这里有一个很有用的类，可以在包含/独占边界的任意组合中生成任意范围内的随机输入:

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

#16

In case of rolling a dice it would be random number between 1 to 6 (not 0 to 6), so:

掷骰子时，随机数为1到6(不是0到6)，因此:

face = 1 + randomNumbers.nextInt(6);

#17

This methods might be convenient to use:

这些方法可能便于使用:

This method will return a random number between the provided min and max value:

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

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

and this method will return a random number from the provided min and max value (so the generated number could also be the min or max number):

该方法将从所提供的最小值和最大值中返回一个随机数(因此生成的数也可以是最小值或最大值):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

#18

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

Or take a look to RandomUtils from Apache Commons.

或者看看Apache Commons中的RandomUtils。

#19

When you need a lot of random numbers, I do not recommend the Random class in the API. It has just a too small period. Try the Mersenne twister instead. There is a Java implementation.

当您需要很多随机数时，我不推荐API中的随机类。它的周期太短了。试试Mersenne twister。有一个Java实现。

#20

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

#21

Here is a simple sample that shows how to generate random number from closed [min, max] range, while min <= max is true

这里有一个简单的示例，展示了如何从封闭的[min, max]范围中生成随机数，而min <= max为真

You can reuse it as field in hole class, also having all Random.class methods in one place

您可以将它作为一个字段在洞类中重用，也可以任意使用。类方法在一个地方

Results example:

结果示例:

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

Sources:

来源:

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

#22

Just use the Random class:

使用随机类:

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

#23

I found this example Generate random numbers :

我发现这个例子产生随机数:

---

This example generates random integers in a specific range.

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

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

An example run of this class :

这个类的一个运行示例:

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.

#24

You can achieve that concisely in Java 8:

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

#25

Another option is just using Apache Commons:

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

#26

If you want to try the answer with the most votes above, you can simply use this code:

如果你想尝试上面投票最多的答案，你可以使用以下代码:

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

    public static void main(String[] args)
    {
        System.out.println(Randomizer.generate(0,10));
    }
}

It is just clean and simple.

它就是干净和简单。

#27

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

#28

It's better to use SecureRandom rather than just Random.

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

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

This is working fine.

这是工作正常。

#30

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