注意，该方法比下一个Int方法更偏向且效率更低，https://stackoverflow.com/a/738651/360211

实现这一点的一个标准模式是：

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

Java Math库函数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-Min）添加1，然后通过强制转换为int来截断小数部分。这可以通过以下方式实现：

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

在[Min，Max]范围内的随机整数值，或者按照示例[5,10]：

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

使用nexttint（n）方法为最小值和最大值的差值生成一个随机数，然后将最小值添加到结果中：

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

尝试使用org.apachemons.lang.RandomStringUtils类。是的，它有时会给出一个相邻的重复数字，但它会给出介于5和15之间的值：

    while (true)
    {
        int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
        int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
        if ((cd-abc) >= 5 && (cd-abc) <= 15)
        {
            System.out.println(cd-abc);
            break;
        }
    }

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

我正在考虑使用以下方法将生成的随机数线性归一化到所需范围。设x为随机数，设a和b为期望归一化数的最小和最大范围。

下面是一个非常简单的代码片段，用来测试线性映射产生的范围。

public static void main(String[] args) {
    int a = 100;
    int b = 1000;
    int lowest = b;
    int highest = a;
    int count = 100000;
    Random random = new Random();
    for (int i = 0; i < count; i++) {
        int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
        if (nextNumber < a || nextNumber > b) {
            System.err.println("number not in range :" + nextNumber);
        }
        else {
            System.out.println(nextNumber);
        }
        if (nextNumber < lowest) {
            lowest = nextNumber;
        }
        if (nextNumber > highest) {
            highest = nextNumber;
        }
    }
    System.out.println("Produced " + count + " numbers from " + lowest
            + " to " + highest);
}

Java中的Math.Random类是基于0的。所以，如果你这样写：

Random rand = new Random();
int x = rand.nextInt(10);

x将介于0-9之间（含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);

为了更好地理解，请查看论坛帖子Random Intervals（archive.org）。