Question

我想在Java中创建一组没有重复的随机数。

例如，我有一个数组来存储从0到9999的10,000个随机整数。

这是我到目前为止所做的：

import java.util.Random;
public class Sort{

    public static void main(String[] args){

        int[] nums = new int[10000];

        Random randomGenerator = new Random();

        for (int i = 0; i < nums.length; ++i){
            nums[i] = randomGenerator.nextInt(10000);
        }
    }
}

但上面的代码会产生重复。如何确保随机数不重复？

Answer 1

Integer[] arr = {...};
Collections.shuffle(Arrays.asList(arr));

例如：

public static void main(String[] args) {
    Integer[] arr = new Integer[1000];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i;
    }
    Collections.shuffle(Arrays.asList(arr));
    System.out.println(Arrays.toString(arr));

}

Answer 2

可以在书Programming Pearls p中找到一个简单的算法，它可以为您提供没有重复的随机数。 127。

注意：结果数组按顺序包含数字！如果您希望它们按随机顺序排列，则必须使用Fisher–Yates shuffle或使用列表并调用Collections.shuffle()来对阵列进行随机播放。

此算法的好处是您不需要创建包含所有可能数字的数组，并且运行时复杂性仍为线性O(n)。

public static int[] sampleRandomNumbersWithoutRepetition(int start, int end, int count) {
    Random rng = new Random();

    int[] result = new int[count];
    int cur = 0;
    int remaining = end - start;
    for (int i = start; i < end && count > 0; i++) {
        double probability = rng.nextDouble();
        if (probability < ((double) count) / (double) remaining) {
            count--;
            result[cur++] = i;
        }
        remaining--;
    }
    return result;
}

Answer 3

Achintya Jha在这里有正确的想法。您没有考虑如何删除重复项，而是删除了首先创建重复项的功能。

如果您想坚持使用一系列整数并想要随机化他们的订单（手动，这很简单），请按照以下步骤操作。

创建大小为n的数组。
循环并将索引i处的每个值初始化为值i（如果希望数字1到n而不是0到n-1，则将i + 1初始化。）
最后，循环遍历数组，再次交换随机索引值的每个值。

您的代码可以修改为如下所示：

import java.util.Random;

public class Sort
{
    // use a constant rather than having the "magic number" 10000 scattered about
    public static final int N = 10000;

    public static void main(String[] args)
    {
        //array to store N random integers (0 - N-1)
        int[] nums = new int[N];

        // initialize each value at index i to the value i 
        for (int i = 0; i < nums.length; ++i)
        {
            nums[i] = i;
        }

        Random randomGenerator = new Random();
        int randomIndex; // the randomly selected index each time through the loop
        int randomValue; // the value at nums[randomIndex] each time through the loop

        // randomize order of values
        for(int i = 0; i < nums.length; ++i)
        {
             // select a random index
             randomIndex = randomGenerator.nextInt(nums.length);

             // swap values
             randomValue = nums[randomIndex];
             nums[randomIndex] = nums[i];
             nums[i] = randomValue;
        }
    }
}

如果我是你，我可能会将这些块中的每一个分解为单独的，较小的方法，而不是使用一个大的主方法。

希望这有帮助。

Answer 4

如果您需要生成带间隔的数字，可以是这样的：

Integer[] arr = new Integer[((int) (Math.random() * (16 - 30) + 30))];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
}
Collections.shuffle(Arrays.asList(arr));
System.out.println(Arrays.toString(arr));`

结果：

[1, 10, 2, 4, 9, 8, 7, 13, 18, 17, 5, 21, 12, 16, 23, 20, 6, 0, 22, 14, 24, 15, 3, 11, 19]

注意：

如果您需要零，那么您可以放置＆＃34; if＆＃34;

Answer 5

这个怎么样？

LinkedHashSet<Integer> test = new LinkedHashSet<Integer>();
Random random = new Random();
do{
    test.add(random.nextInt(1000) + 1);
}while(test.size() != 1000);

然后，用户可以使用for循环遍历Set。

Answer 6

在Java 8中，如果您希望在list中有N个非重复range (a, b)个随机整数，其中b是独占的，您可以使用类似的东西这样：

Random random = new Random();
List<Integer> randomNumbers = random.ints(a, b).distinct().limit(N).boxed().collect(Collectors.toList());

Answer 7

我们在这里！

public static int getRandomInt(int lower, int upper) {
    if(lower > upper) return 0;
    if(lower == upper) return lower;
    int difference = upper - lower;
    int start = getRandomInt();

    //nonneg int in the range 0..difference - 1
    start = Math.abs(start) % (difference+1);

    start += lower;
    return start;
}

public static void main(String[] args){

    List<Integer> a= new ArrayList();

    int i;
    int c=0;
    for(;;) {
        c++;
        i= getRandomInt(100, 500000);
        if(!(a.contains(i))) {
            a.add(i);
            if (c == 10000) break;
            System.out.println(i);
        }


    }

    for(int rand : a) {
        System.out.println(rand);
    }



}

获取随机数返回满足下限<= x <=上限的随机整数x。如果lower> upper，则返回0。@param lower @param upper @return

在创建列表的主要方法中，我检查列表中是否存在随机数（如果不存在），我会将随机数添加到列表中

Answer 8

如果您使用的是JAVA 8或更高版本，请按照以下方式使用流功能，

Stream.generate（（）->（new Random（））。nextInt（10000））。distinct（）。limit（10000）;

Answer 9

public class RandomNum {
    public static void main(String[] args) {
        Random rn = new Random();
        HashSet<Integer> hSet = new HashSet<>();
        while(hSet.size() != 1000) {
            hSet.add(rn.nextInt(1000));
        }
        System.out.println(hSet);
    }
}

Answer 10

一个简单的流解决方案：

   new Random().ints(0, 10000)
        .distinct()
        .limit(10000)
        .forEach(System.out::println);

Answer 11

public class Randoms {

static int z, a = 1111, b = 9999, r;

public static void main(String ... args[])
{
       rand();
}

    public static void rand() {

    Random ran = new Random();
    for (int i = 1; i == 1; i++) {
        z = ran.nextInt(b - a + 1) + a;
        System.out.println(z);
        randcheck();
    }
}

private static void randcheck() {

    for (int i = 3; i >= 0; i--) {
        if (z != 0) {
            r = z % 10;
            arr[i] = r;
            z = z / 10;
        }
    }
    for (int i = 0; i <= 3; i++) {
        for (int j = i + 1; j <= 3; j++) {
            if (arr[i] == arr[j]) {
                rand();
            }
        }

    }
}
}

Answer 12

foreach ($this->data as $key => $value) 
{
    $this->$key();
}

Java生成非重复随机数

12 个答案: