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

它干净而简单.

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

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

使用最高值初始化max,使用最低值初始化min.

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

5,6,7,8,9,10

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

即10 - 5 + 1 = 6

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

即0,1,2,3,4,5

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

5,6,7,8,9,10

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

 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 7开始,您不应再使用Random.对于大多数用途,现在选择随机数生成器 ThreadLocalRandom.

对于fork连接池和并行流,请使用SplittableRandom.

约书亚布洛赫.有效的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;
}

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 ls =  new ArrayList();

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

你可以用

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;