Java 八个随机整数的数组，其中每个整数与数组中所有其他整数的差值至少为15？

我正在尝试编写一个方法，该方法创建并返回一个长度为8且在

[25725]

范围内的随机

整数

数组

数组中的每一个

Integer

必须比数组中的每一个

Integer

高或低至少15。但是，我的方法不会返回满足此要求的数组

我设置了一个

main（）

方法来检查方法的输出100000次，如果有任何

整数

太接近，则抛出一个

异常

我如何创建一个方法来返回一个
整数数组，其中每个
整数
与每个其他
整数
之间的差值至少为15

公共类测试{
公共静态void main（字符串[]args）引发异常{
整数[]距离=新整数[8]；
对于（int i=0；i<100000；i++）{
距离=createPlanetDistances（距离.长度）；
//检查距离值是否在15以内
对于（int x=0；x
要查找
计数
范围
最小值
到
最大值
（排除）中相距超过
距离
的数字，请构建一个值并使用该方法查找附近的值

范例

如果不希望结果按升序排列，则始终可以对其进行洗牌

工作原理

ceiling
方法返回集合中大于或等于给定值的最小值，如果没有此类值，则返回null

因此，如果
值
为134，
距离
为15，则
上限（值-距离）
将找到>=119的最小值。如果该值>=149，则我们知道附近的范围119-149是清晰的，我们可以使用134值。
要查找
最小值
到
最大值
（排除）范围内的
计数
数，请构建一个函数并使用该方法查找附近的值

范例

如果不希望结果按升序排列，则始终可以对其进行洗牌

工作原理

ceiling
方法返回集合中大于或等于给定值的最小值，如果没有此类值，则返回null

因此，如果
值
为134，
距离
为15，则
上限（值-距离）
将找到>=119的最小值。如果该值>=149，那么我们知道附近的范围119-149是清晰的，我们可以使用134值。
您正在生成行星轨道，因此应该可以使用单调递增的数字。生成的每个数字都有以下数字对其施加的约束，并在生成后对其施加约束

约束：如果要在
min
和
max
之间生成由
D
分隔的
N
轨道，则第一个轨道的边界为
[min，max-D*（N-1）]
。这仅仅是因为你不能将下列
N-1
行星打包到小于
D*（N-1）
的空间中

您可以在运行时更新第二个约束，因为新的最小值将是最后生成的数字+
D
。下面是一个简单的
O（n）
实现（假设生成一个随机数是
O（1）
）：

final int DISTANCE=15，MIN=25，MAX=726，COUNT=8；
随机=随机（）；
轨道=新整数[计数]；
如果（最大-最小<距离*计数）{
抛出新的IllegalArgumentE
final int DISTANCE = 15, MIN = 25, MAX = 726, COUNT = 8;

ThreadLocalRandom random = ThreadLocalRandom.current();
TreeSet<Integer> numbers = new TreeSet<>();
while (numbers.size() < COUNT) {
    int value = random.nextInt(MIN, MAX);
    Integer ceiling = numbers.ceiling(value - DISTANCE);
    if (ceiling == null || ceiling > value + DISTANCE)
        numbers.add(value);
}
System.out.println(numbers);

final int DISTANCE = 15, MIN = 25, MAX = 726, COUNT = 8;
Random random = Random();

orbits = new int[COUNT];

if(MAX - MIN < DISTANCE * COUNT) {
    throw new IllegalArgumentException("Insert pithy comment about COUNT");
}

min = MIN;
for(int i = 0; i < COUNT; i++) {
    max = MAX - DISTANCE * (COUNT - i - 1);
    orbits[i] = random.nextInt(max - min + 1) + min;
    min = orbits[i] + DISTANCE;
}

static Random r = new Random();

public static ArrayList<Integer>
    gen_array(int lower_bound, int upper_bound, int n, int separation) {
    upper_bound -= (n - 1) * separation;

    if(upper_bound < lower_bound) {
        throw new IllegalArgumentException("Infeasible arguments");
    }

    ArrayList<Integer> ary = new ArrayList<>();
    while(ary.size() < n) {
        ary.add(lower_bound + r.nextInt(upper_bound - lower_bound + 1));
    }
    Collections.sort(ary);
    for (int i = 0; i < n; ++i) {
        ary.set(i, ary.get(i) + i * separation);
    }
    Collections.shuffle(ary);
    return ary;
}