Java 具有不同值的随机数组生成器

我必须创建一个Java程序，它创建一个由5个元素组成的数组，随机值在1到55之间，这些值必须与数组中以前的值不同。我试过这种方法，但实际上似乎不起作用

import java.util.Random;

public class RandomArray {
    public static void main(String args[]) {
        Random x = new Random(System.nanoTime());
        int i, y, c = 0;
        int v[] = new int[5];
        for (i = 0; i < 5; i++) {
            c++;
            v[i] = x.nextInt(56);
            for (y = 0; y < c; y++) {
                while (v[y] == v[i]||v[i] == 0) v[i] = x.nextInt(56);
            }
        }
        for (int z : v) System.out.println(z);
    }
}

import java.util.Random；
公共类随机数组{
公共静态void main（字符串参数[]）{
Random x=新的Random（System.nanoTime（））；
int i，y，c=0；
int v[]=新int[5]；
对于（i=0；i<5；i++）{
C++；
v[i]=x.nextInt（56）；
对于（y=0；y

我避开了试图理解您的代码在做什么或不在做什么，因为我认为在Java中向集合添加5个唯一数字不是最好的方法。您需要唯一的值，这将非常适合集合

这里的一个选项是使用一个集合来存储随机数，并不断添加数字，直到集合的大小达到5：

Random x = new Random(System.nanoTime());
Set<Integer> rNum = new HashSet<>();

while (rNum.size() < 5) {
    rNum.add(x.nextInt(56));
}

int v[] = new int[5];
int c = 0;
for (int num : rNum) {
    v[c] = num;
    ++c;
}

Random x=new Random（System.nanoTime（））；
Set rNum=new HashSet（）；
而（rNum.size（）<5）{
加上（x.nextInt（56））；
}
int v[]=新int[5]；
int c=0；
for（int num:rNum）{
v[c]=num；
++c；
}

---

代码的问题在于，您正在将当前值与自身值进行比较，因此存在无休止的循环。这更好地表达了你的意图：

    Random x = new Random(System.nanoTime());
    int v[] = new int[5];
    for (int i = 0; i < 5; i++) {
        v[i] = 1 + x.nextInt(55);
        for (int y = 0; y < i; y++) {
            while (v[y] == v[i])
                v[i] = 1 + x.nextInt(55);
        }
    }
    for (int z : v)
        System.out.println(z);

Random x=new Random（System.nanoTime（））；
int v[]=新int[5]；
对于（int i=0；i<5；i++）{
v[i]=1+x.nextInt（55）；
对于（int y=0；y

我们可以使用生成长度序列

n=limit&&i>0--(一){
int swapIdx=rng.nextInt（i）；
int tmp=范围[swapIdx]；
范围[swapIdx]=范围[i]；
范围[i]=tmp；
}
返回array.copyOfRange（范围、限制、范围、长度）；
}
}

我们一直使用相同的源数组

范围

，即使它已经有点混淆了。这并不会改变这种可能性，因为Fisher-Yates shuffle保证了一个均匀分布的数组（即，每个数字在洗牌后位于

i

th位置的概率为

1/n

，其中

n

是数组大小

此算法具有以下特性：

• 它可证明终止。和的两个答案都不能保证终止1
• 它使用所需的最小随机性，即当生成长度为

  n

  的随机序列时，它总是只使用

  n

  调用

  rng.nextInt（…）

  。如果需要长度为

  range.length

  的随机序列，则它只需要

  range.length-1

  随机调用

---

1尽管两种算法都很可能终止。

您可以使用此选项

Random x = new Random(System.nanoTime());
int i, y, c = 0;
int v[] = new int[5];
 for (i = 0; i < 5; i++) {
  c++;
  v[i] = x.nextInt(56);
  for (y = 0; y < c; y++) {
   //SOLUTION
   int aux = v[i];
   while (aux == v[y]||v[y] == 0) v[y] = x.nextInt(56);
   //
  }
}
for (int z : v) System.out.println(z);

Random x=new Random（System.nanoTime（））；
int i，y，c=0；
int v[]=新int[5]；
对于（i=0；i<5；i++）{
C++；
v[i]=x.nextInt（56）；
对于（y=0；y

---

在另一种情况下，你有一个无休止的循环，因为你一直在比较，因为v[0]==v[0]一直都是真的

“但它实际上似乎不起作用”-问题是什么？似乎不起作用，或者明显不起作用。其中一个问题比另一个问题更容易回答。在你问之前，你应该搜索，好吗？` while（v[y]==v[i]| v[i]==0）v[i]=x.nextInt（56）59。

Random x = new Random(System.nanoTime());
int i, y, c = 0;
int v[] = new int[5];
 for (i = 0; i < 5; i++) {
  c++;
  v[i] = x.nextInt(56);
  for (y = 0; y < c; y++) {
   //SOLUTION
   int aux = v[i];
   while (aux == v[y]||v[y] == 0) v[y] = x.nextInt(56);
   //
  }
}
for (int z : v) System.out.println(z);