提问



如何在特定范围内生成随机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实例,如果使用不当,可能会造成混淆和错误。[104] [105]


然而,相反地,没有办法明确地设置种子,因此在有用的情况下(例如测试或保存游戏状态或类似情况)可能难以再现结果。在这些情况下,可以使用下面显示的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()更可取。[106] [107] [108]


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

其它参考1


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


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


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


Java Math库函数Math.random()生成[0,1)范围内的double值。请注意,此范围不包括1. [110]


为了首先获得特定范围的值,您需要乘以您想要覆盖的值范围的大小。


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值,你需要在你的范围参数(Max - Min)中加1,然后通过强制转换为int来截断小数部分。这可以通过以下方式实现:


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


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


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

其它参考2


使用:


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


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

其它参考3


使用:


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

其它参考4


使用java-8,他们在Random类中引入了ints(int randomNumberOrigin, int randomNumberBound)方法。/questions/tagged/java-8 [112] [113]


例如,如果要在[[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值执行此操作。


希望能帮助到你! :)

其它参考5


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


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

其它参考6


只需对您的第一个解决方案进行一些小修改就足够了。


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





在此处查看更多Random [114]的实施

其它参考7


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


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


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

其它参考8


Java中的Math.Random类是从0开始的。所以,如果你写这样的东西:[115]


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


为了更好地理解,请查看论坛帖子随机间隔(archive.org)。[116]

其它参考9


请原谅我的挑剔,但多数人建议的解决方案,即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%或更高。

其它参考10


我想知道Apache Commons Math库提供的任何随机数生成方法是否符合要求。 [117]


例如:RandomDataGenerator.nextIntRandomDataGenerator.nextLong [118] [119]

其它参考11


让我们举个例子。


假设我希望在 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

    

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

  


其它参考12


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

其它参考13


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


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

其它参考14


这是一个有用的类,可以在包含/排除边界的任意组合的范围内生成随机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;
    }
}

其它参考15


在滚动骰子的情况下,它将是1到6之间的随机数(不是0到6),因此:


face = 1 + randomNumbers.nextInt(6);

其它参考16


这种方法可能很方便使用:


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


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

其它参考17


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


或者看看Apache Commons的RandomUtils。[121]

其它参考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);

其它参考19


当您需要大量随机数时,我不推荐API中的Random类。这个时期太短了。试试Mersenne twister代替。有一个Java实现。[122] [123]

其它参考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


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

其它参考22


只需使用Random类:[124]


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

其它参考23


我发现这个例子生成随机数:[125]





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


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.

其它参考24


另一种选择是使用Apache Commons:[126]


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

其它参考25



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

对于fork连接池和并行
  流,使用SplittableRandom[128]



Joshua Bloch。有效的Java。第三版。


从Java 8开始



对于fork连接池和并行流,使用SplittableRandom通常更快,与Random相比具有更好的统计独立性和均匀性。


[0, 1_000]:范围内生成随机int


int n = new SplittableRandom().nextInt(0, 1_001);


生成[0, 1_000]:范围内的随机int[100]值数组


int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();


要返回随机值流:


IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

其它参考26


如果您想尝试上述投票最多的答案,您可以使用以下代码:


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


它干净而简单。

其它参考27


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

其它参考28


使用SecureRandom而不仅仅是随机更好。[129]


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;


这工作正常。