对第一个解决方案稍作修改就足够了。

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

更多信息请参见此处了解 Random

这个 Math.Random java中的类是基于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);

为了更好的理解，请查看论坛帖子随机间隔（archive.org）。

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

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

只需执行以下语句：

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

它只是简单明了。

在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来完成任务时，就不需要重新设计随机整数生成轮。

用途：

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

整数 x 现在是一个随机数，可能的结果是 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);

让我们明白。。。
用最大值初始化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
因此我们得到了所需的范围。

请原谅我的挑剔，但是大多数人建议的解决办法，即。， min + rng.nextInt(max - min + 1)) ，似乎很危险，因为： rng.nextInt(n) 无法到达 Integer.MAX_VALUE . (max - min) 可能导致溢出时 min 是阴性。
一个简单的解决方案将返回正确的结果 min <= max 内[ Integer.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;
}

虽然效率低下，但要注意成功的概率在 while 循环将始终为50%或更高。

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

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.

要生成“介于两个数字之间”的随机数，请使用以下代码：

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

这将给您一个介于1（包含）和11（排除）之间的随机数，因此通过加1来初始化上限值。例如，如果要生成1到10之间的随机数，则用11而不是10初始化上界数。

他们用java-8引入了这个方法 ints(int randomNumberOrigin, int randomNumberBound) 在 Random 班级。
例如，如果要生成[0，10]范围内的五个随机整数（或单个整数），只需执行以下操作：

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

第一个参数仅指示 IntStream generated（这是产生无限 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 价值观。希望有帮助！：）

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

用途：

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

使用nextint（n）方法为min和max的差生成一个随机数，然后将min number添加到结果中：

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

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

这很有效。