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

Posted 2023-02-25

【中文标题】如何在 Java 中生成特定范围内的随机整数？

【英文标题】：How do I generate random integers within a specific range in Java?

【发布时间】：2010-09-26 16:39:41

【问题描述】：

如何在特定范围内生成随机的int 值？

我尝试了以下方法，但都不起作用：

尝试 1：

randomNum = minimum + (int)(Math.random() * maximum);

错误：randomNum 可以大于 maximum。

尝试 2：

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

错误：randomNum 可以小于 minimum。

【问题讨论】：

当你需要大量随机数时，我不推荐API中的Random类。它的周期太短了。请改用Mersenne twister。有a Java implementation。

在发布新答案之前，请考虑此问题已有 65 多个答案。请确保您的答案提供的信息不在现有答案中。

【参考方案1】：

如果我们有安全敏感的应用，我们应该使用 SecureRandom。

    import java.security.SecureRandom;

    public class Main 
      public static void main(String... args)
        int max=13;
        int min =1;
        int randomWithSecureRandom = new SecureRandom().nextInt(max - min) + min;
        System.out.println(randomWithSecureRandom);
      
    

【参考方案2】：

int randomNum = 5+(int)(Math.random() * 5);

范围 5-10

【参考方案3】：

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

【参考方案4】：

您可以按照以下方式进行操作。

import java.util.Random;
public class RandomTestClass 

    public static void main(String[] args) 
        Random r = new Random();
        int max, min;
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter maximum value : ");
        max = scanner.nextInt();
        System.out.println("Enter minimum value : ");
        min = scanner.nextInt();
        int randomNum;
        randomNum = r.nextInt(max) + min;
        System.out.println("Random Number : " + randomNum);
    

【参考方案5】：

为了避免重复多次说过的话，我将通过使用 SecureRandom 类为那些需要加密更强的伪随机数生成器的人展示一个替代方案，该类扩展了类 Random。来自source 可以阅读：

这个类提供了一个加密的强随机数生成器 (RNG)。 一个加密的强随机数至少符合 使用 FIPS 中指定的统计随机数生成器测试 140-2，加密模块的安全要求，第 4.9.1 节。 此外，SecureRandom 必须产生非确定性的输出。 因此，任何传递给 SecureRandom 对象的种子材料都必须是 不可预测，并且所有 SecureRandom 输出序列必须是 加密性强，如 RFC 1750：随机性中所述 安全建议。

调用者通过无参数获取 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 ));
    

***、baeldung、geeksforgeeks 等来源提供了 Random 和 SecureRandom 类之间的比较。

来自baeldung 可以阅读：

使用 SecureRandom 最常见的方式是生成 int、long、 浮点、双精度或布尔值：

int randomInt = secureRandom.nextInt(); long randomLong = secureRandom.nextLong(); 浮动 randomFloat = secureRandom.nextFloat(); 双 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);

此类提供了几个其他选项（例如选择基础随机数生成器），这些选项超出了本问题的范围。

【参考方案6】：

使用 Apache Lang3 Commons

Integer.parseInt(RandomStringUtils.randomNumeric(6, 6));

最小值 100000 到最大值 999999

【讨论】：

既然可以有简单的解决方案，为什么还要让生活变得如此复杂:)

我想，这是最简单的给定范围内的随机数。

生成的数字可以从零开始！

这会产生一个字符串，而不是整数，因此不是问题的答案。

它返回 \pDigit

【参考方案7】：

您可以使用以下方法来做到这一点

int range = 10;
int min = 5
Random r = new Random();
int  = r.nextInt(range) + min;

【参考方案8】：

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;

【讨论】：

这似乎只是许多现有答案的重复。

【参考方案9】：

下面的 sn-p 会给出一个 0 到 10000 之间的随机值：

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

【讨论】：

感谢您提供此代码 sn-p，它可能会提供一些有限的短期帮助。一个正确的解释would greatly improve 其长期价值，通过展示为什么这是解决问题的好方法，并将使其对未来有其他类似问题的读者更有用。请edit您的回答添加一些解释，包括您所做的假设。特别是，这段代码如何接受问题陈述的下限和上限并不明显。

【参考方案10】：

通过java-8，他们在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 值执行此操作。我希望它有帮助！ :)

【讨论】：

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

【参考方案11】：

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

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

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

【参考方案12】：

我用这个：

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

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

【讨论】：

这个函数一遍又一遍地产生相同的数字。就我而言，它是：2147483647

失败：你有一个函数需要一个double然后执行+1？这当然违背了最小意外的原则。如果使用 min = 0.1 和 max = 0.2 会发生什么？

@sokras 该方法调用new Random（检查JavaDoc）：“创建一个新的随机数生成器。此构造函数将随机数生成器的种子设置为一个很可能不同于任何此构造函数的其他调用。”很可能只涉及使用当前时间作为种子。如果该时间使用毫秒，那么当前计算机的速度足以生成相同的数字。但除此之外，2147483647 是Integer.MAX_VALUE；输出显然取决于您没有指定的输入。

【参考方案13】：

这是一个函数，它根据lowerBoundIncluded和upperBoundIncluded定义的范围内精确返回一个整数随机数，用户42155

SplittableRandom splittableRandom = new SplittableRandom();

BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
    -> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );

randomInt.apply( …, … ); // gets the random number

…或者更短的随机数的一次性生成

new SplittableRandom().nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );

【参考方案14】：

只要简单的做一下语句就可以做到：

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

简洁明了。

【讨论】：

这可能是对另一个示例的编辑，现在它只是为了声誉而公然复制。指出“得票最多的答案”也不是很直接，可以改变。

没错@MaartenBodewes。当我写这个答案时，the answer with the most votes above 仍然被写成类似算法的解决方案。现在，上面的解决方案已经发生了很大变化，现在这个答案看起来像一个模仿猫。

我真的不明白为什么这些基本代码位不是 Java 标准库的一部分。为什么我必须实现这个？

这对我很有帮助，@AbelCallejo。谢谢！别介意你收到的关于抄袭的负面评论；所有答案都有帮助。

【参考方案15】：

可以使用以下代码：

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

【讨论】：

已经有多个答案建议ThreadLocalRandom。如果问题受到保护，请格外小心不要重复答案。

【参考方案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);

【参考方案17】：

只需使用Random 类：

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

【讨论】：

我在这里没有看到任何以前无数帖子中没有发布过的新内容。

@MaartenBodewes 那些无数的帖子很难找到。上面的一些其他方法

是的，再发一个骗子也无济于事。投票赞成其他答案或添加详细信息。否则，它只是代表农业。

【参考方案18】：

使用nextint(n) 方法为最小值和最大值的差生成一个随机数，然后将最小值添加到结果中：

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

【参考方案19】：

这是执行此操作的简单方法。

import java.util.Random;
class Example
    public static void main(String args[])
        /*-To test-
        for(int i = 1 ;i<20 ; i++)
            System.out.print(randomnumber()+",");
        
        */

        int randomnumber = randomnumber();

    

    public static int randomnumber()
        Random rand = new Random();
        int randomNum = rand.nextInt(6) + 5;

        return randomNum;
    

其中 5 是随机数的起点。 6 是包含数字 5 的范围。

【参考方案20】：

在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。

【讨论】：

除了使用流的其他答案之外，至少它们不会在循环中创建新流，现在这真的没有意义。

【参考方案21】：

我找到了这个例子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】：

这些方法使用起来可能很方便：

此方法将返回一个随机数提供的最小值和最大值：

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。答案错误，投了反对票。

@MaartenBodewes +1 被添加，因为 getRandomNumberBetween 生成一个不包括提供的端点的随机数。

数字min + 1 成为getRandomNumberBetween 的结果的可能性是其他数字的两倍！

【参考方案23】：

以下代码生成一个介于 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);

【参考方案24】：

只需对您的第一个解决方案稍作修改即可。

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

---

在这里查看更多Random的实现

【讨论】：

对于最小值 randomNum = minimum + (int)(Math.random() * (maximum-minimum)); 但是演员阵容并不是很好看 ;)

至少迟到 7 年重复答案。

这对我作为初学者来说是最容易实现的。谢谢！

【参考方案25】：

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

【讨论】：

为什么你将 index 实例化为 0 让我感到困惑。

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

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

或者根本没有。 int index; \n index = rand... 如果一个人喜欢在不同的行上声明和赋值。一些编码标准比其他编码标准更严格（并且没有明显的目的）。

【参考方案26】：

用途：

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

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

【参考方案27】：

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

【参考方案28】：

让我们举个例子。

假设我希望生成一个介于 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

将 min 值添加到随机数会产生：

5、6、7、8、9、10

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

【参考方案29】：

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

实现此目的的一个标准模式是：

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

Java 数学库函数 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 的值，您需要将1 加到您的范围参数(Max - Min)，然后通过强制转换为int 来截断小数部分。这是通过以下方式完成的：

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

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

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

【讨论】：

Sun 文档明确指出，如果您需要一个 int 而不是 Math.random() 生成双精度值，则最好使用 Random()。

与 nextInt 方法相比，这实际上是有偏差的 ***.com/a/738651/360211

"Biased" 在这种情况下意味着在 2^53 次执行后，一些数字平均会多出现一次。

即使我也使用这个，我想指出这不是一个真正的随机数。这就是为什么它不应该用于任何安全功能。但对于任何偶然的情况，这是最直接的方法。

【参考方案30】：

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