Java生成非重复随机数

我想在Java中创建一组无重复的随机数

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

以下是我到目前为止的情况：

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

import java.util.Random；
公共类排序{
公共静态void main（字符串[]args）{
int[]nums=新int[10000]；
Random randomGenerator=新的Random（）；
对于（int i=0；i

但是上面的代码创建了重复的代码。如何确保随机数不会重复

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

}

publicstaticvoidmain（字符串[]args）{
整数[]arr=新整数[1000]；
对于（int i=0；i

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

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

import java.util.Random；
公共类排序
{
//使用一个常量，而不是将“幻数”10000分散在周围
公共静态最终整数N=10000；
公共静态void main（字符串[]args）
{
//存储N个随机整数（0-N-1）的数组
int[]nums=新的int[N]；
//将索引i处的每个值初始化为值i
对于（int i=0；i

如果我是你的话，我可能会把这些块分解成单独的、更小的方法，而不是一个大的主方法

希望这有帮助。

公共类随机{
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();
            }
        }

    }
}
}

静态整数z，a=1111，b=9999，r；
公共静态void main（字符串…参数[]）
{
兰德（）；
}
公共静态void rand（）{
Random ran=新的Random（）；
for（int i=1；i==1；i++）{
z=ran.nextInt（b-a+1）+a；
系统输出打印ln（z）；
randcheck（）；
}
}
私有静态void randcheck（）{
对于（int i=3；i>=0；i--）{
如果（z！=0）{
r=z%10；
arr[i]=r；
z=z/10；
}
}
对于（inti=0；i一个简单的算法，可以在第127页的书中找到，该算法可以给出无重复的随机数

注意：生成的数组包含按顺序排列的数字！如果希望它们按随机顺序排列，则必须使用列表或使用列表对数组进行无序排列，然后调用
Collections.shuffle（）

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

public static int[]sampler和omnumbers不重复（int开始、int结束、int计数）{
随机rng=新随机（）；
int[]结果=新的int[计数]；
int cur=0；
剩余整数=结束-开始；
对于（int i=start；i0；i++）{
双概率=rng.nextDouble（）；
如果（概率<（（双）计数）/（双）剩余）{
计数--；
结果[cur++]=i；
}
剩余--；
}
返回结果；
}
这个怎么样

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

LinkedHashSet测试=新建LinkedHashSet（）；
随机=新随机（）；
做{
测试。添加（随机。nextInt（1000）+1）；
}而（test.size（）！=1000）；

然后，用户可以使用for循环遍历
集合。
如果需要生成带间隔的数字，可以如下所示：

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

Integer[]arr=newinteger[（（int）（Math.random（）*（16-30）+30））；
对于（int i=0；i

结果是：

[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]

注:

如果您需要零不离开，您可以在Java 8中放置一个“If”
，如果您希望在
范围（a，b）
中有一个非重复的
N
随机整数的
列表，其中
b
是独占的，您可以使用如下内容：

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

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

Random Random=new Random（）；
List randomNumbers=random.int（a，b）.distinct（）.limit（N）.boxed（）.collect（Collectors.toList（））；
HashSethashSet=newhashset（）；
随机=新随机（）；
//现在将随机数添加到此集合
while（true）
{
add（random.nextInt（1000））；
if（hashSet.size（）==1000）
打破
}
我们开始了

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

public static int getRandomInt（int-lower，int-upper）{
如果（下限>上限）返回0；
如果（下限==上限），则返回下限；
积分差=上-下；
int start=getRandomInt（）；
//范围为0..difference-1的非负整数
开始=数学abs（开始）%（差值+1）；
开始+=较低；
返回启动；
}
普布利
Stream.generate(() -> (new Random()).nextInt(10000)).distinct().limit(10000);

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