请原谅我的挑剔，但是大多数人建议的解决办法，即。， 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%或更高。

这个 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）。

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

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

在掷骰子的情况下，它将是1到6（不是0到6）之间的随机数，因此：

face = 1 + randomNumbers.nextInt(6);

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

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

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

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

您可以将第二个代码示例编辑为：

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

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

或者看看apache commons中的randomutils。

从Java7开始，您不应该再使用 Random . 对于大多数用途，随机数发生器的选择是现在 ThreadLocalRandom .
对于fork-join池和并行流，使用 SplittableRandom .
约书亚·布洛赫。有效的java。第三版。

从Java8开始

对于fork-join池和并行流，使用 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);

他们用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 价值观。希望有帮助！：）

最好使用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;
}

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

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

这很有效。

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

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

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

用途：

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

整数 x 现在是一个随机数，可能的结果是 5-10 .