我发现这个例子可以生成随机数：
本例生成特定范围内的随机整数。

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.

下面是一个生成随机变量的有用类 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;
    }
}

这种方法使用起来可能很方便：
此方法将返回所提供的最小值和最大值之间的随机数：

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

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

请注意，这种方法比传统方法更偏颇，效率更低 nextInt 接近，https://stackoverflow.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 + (Math.random() * (Max - Min))

您现在将获得范围内的值 [Min,Max) . 以我们为例，这意味着 [5,10) :

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

但是，这还不包括 Max 你得到了一个双倍的值。为了得到 Max 如果包含值，则需要在range参数中添加1 (Max - Min) 然后通过强制转换为int来截断小数部分。这是通过以下方式实现的：

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

就在这里。范围内的随机整数值 [Min,Max] ，或根据示例 [5,10] :

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

只需使用随机类：

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

下面是一个简单的示例，演示如何从闭合的 [min, max] 范围，而 min <= max is true 您可以在hole类中将其作为字段重用，同时还具有 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;
    }
}

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

我想知道apachecommons数学库提供的任何随机数生成方法是否符合要求。
例如： RandomDataGenerator.nextInt 或者 RandomDataGenerator.nextLong

我用这个：

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

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

只需执行以下语句：

Randomizer.generate(0,10); //min of zero, max of ten

下面是它的源代码

随机发生器.java

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

它只是简单明了。

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

int rand = ThreadLocalRandom.current().nextInt(x,y);
``` `x` , `y` -间隔，例如（1,10）

在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示例，如果使用不当，这可能会导致混淆和错误。
然而，相反地，没有办法显式地设置种子，因此在测试或保存游戏状态或类似的情况下，很难再现有用的结果。在这些情况下，可以使用下面所示的Java1.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来完成任务时，就不需要重新设计随机整数生成轮。

让我们举个例子。
假设我希望生成一个介于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
所以，这个数应该是max-min+1。
i、 e.10-5+1=6
随机数将产生一个0-5之间的数字。
i、 e.0、1、2、3、4、5
将最小值添加到随机数将产生：
5, 6, 7, 8, 9, 10
因此我们得到了所需的范围。

用途：

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