使用基本技术生成10个随机数而不重复

Question

我的意图是使用最简单的java（数组和循环）生成无重复的随机数...但输出结果是10个重复数字，我无法弄清楚原因。

这是我的代码：

int[] number = new int[10];
int count = 0;
int num;

while (count < number.length) {
    num = r.nextInt(21);
    boolean repeat = false;
    do {
        for (int i=0; i<number.length; i++) {
            if (num == number[i]) {
                repeat = true;
            } else if (num != number[i] && i == count) {
                number[count] = num;
                count++;
                repeat = true;
            }
        }
    } while (!repeat);
}

for (int j = 0; j < number.length; j++) {
    System.out.print(number[j] + " ");
}

Answer 1

您如何使用Set代替？如果您还想跟踪插入顺序，可以使用LinkedHashSet。

Random r = new Random();
Set<Integer> uniqueNumbers = new HashSet<>();
while (uniqueNumbers.size()<10){
    uniqueNumbers.add(r.nextInt(21));
}
for (Integer i : uniqueNumbers){
    System.out.print(i+" ");
}

java中的Set类似于Array或ArrayList，除了它为您处理重复项。如果集合中尚不存在Integer，它只会将Set添加到集合中。类Array具有与您可以使用的Set.size()类似的方法。例如，Array.length相当于Set.add(Integer)，Array[index] = value等同于create temporary view task_depcount as select t.* from task t left join taskdependency d on t.id = d.task_id left join task p on d.parent_task_id = p.id group by t.id having not bool_or(p.status != success) or not bool_or(d.task_id is not null) ; select t.id, t.task_type, t.status from task_depcount t where t.status = 'READY' 。集合不跟踪插入顺序，因此它们没有索引。一旦你了解它，它就是Java中非常强大的工具。 ;）

希望这有帮助！

Answer 2

您的代码将在以下条件下中断while循环：num == number[i]。

这意味着如果伪生成的数字等于那个位置值（java中的默认int为0），则代码将结束执行。

在第二个条件句中，表达式num != number[i]始终为true（否则代码将输入之前的if），但是，在第一次运行时，i == count（或{ {1}}和i=0）count=0打破了循环，没有其他任何事情会发生，使输出呈现如

repeat=true

Answer 3

试试这个：

    int[] number = new int[10];
    java.util.Random r = new java.util.Random();

    for(int i=0; i<number.length; i++){
        boolean repeat=false;

        do{
            repeat=false;

            int num = r.nextInt(21);
            for(int j=0; j<number.length; j++){
                if(number[j]==num){
                    repeat=true;
                }
            }

            if(!repeat) number[i]=num;

        }while(repeat);
    }

    for (int k = 0; k < number.length; k++) {
        System.out.print(number[k] + " ");
    }
    System.out.println();

Test it here

Answer 4

如果满足其中任何一个条件，则需要break循环for。

    int[] number = new int[10];
    int count=0;
    int num;
    Random r = new Random();
    while(count<number.length){
        num = r.nextInt(21);
        boolean repeat=false;
        do{
            for(int i=0; i<number.length; i++){
                if(num==number[i]){
                    repeat=true;
                    break;
                }
                else if(i==count){
                    number[count]=num;
                    count++;
                    repeat=true;
                    break;
                }
            }
        }while(!repeat);

    }

    for(int j=0;j<number.length;j++){
        System.out.print(number[j]+" ");
    }

这将使您的代码有效，但@gonzo提出了更好的解决方案。

Answer 5

我相信问题更容易解决。您可以使用List来检查数字是否已生成（唯一性）。这是一个工作代码块。

    int count=0;
    int num;
    Random r = new Random();
    List<Integer> numbers = new ArrayList<Integer>();


    while (count<10) {        
        num = r.nextInt(21);  
        if(!numbers.contains(num) ) {
            numbers.add(num);
            count++;
        }
    }

    for(int j=0;j<10;j++){
        System.out.print(numbers.get(j)+" ");
    }       
}    

Answer 6

让我们从最简单的方法开始，将10个随机 - 可能重复的数字 - 放入数组中：

public class NonUniqueRandoms
{
    public static void main(String[] args)
    {
        int[] number = new int[10];
        int count = 0;

        while (count < number.length) {
            // Use ThreadLocalRandom so this is a contained compilable unit
            number[count++] = ThreadLocalRandom.current().nextInt(21);
        }

        for (int j = 0; j < number.length; j++) {
            System.out.println(number[j]);
        }
    }
}

这样你就可以获得大部分路径，你唯一知道的就是选择一个数字并检查你的数组：

public class UniqueRandoms
{
    public static void main(String[] args)
    {
        int[] number = new int[10];
        int count = 0;

        while (count < number.length) {
            // Use ThreadLocalRandom so this is a contained compilable unit
            int candidate = ThreadLocalRandom.current().nextInt(21);

            // Is candidate in our array already?
            boolean exists = false;
            for (int i = 0; i < count; i++) {
                if (number[i] == candidate) {
                    exists = true;
                    break;
                }
            }

            // We didn't find it, so we're good to add it to the array
            if (!exists) {
                number[count++] = candidate;
            }
        }

        for (int j = 0; j < number.length; j++) {
            System.out.println(number[j]);
        }
    }
}

Answer 7

问题在于你的内在'for'循环。一旦程序找到一个唯一的整数，它就会将整数添加到数组中，然后递增计数。在下一个循环迭代中，将再次添加新的整数，因为（num！= number [i]＆amp;＆amp; i == count），最终用相同的整数填充数组。第一次添加唯一整数后，for循环需要退出。

但是如果我们更深入地研究构造，我们会发现内部for循环是完全没必要的。

请参阅下面的代码。

   import java.util.*;

   public class RandomDemo {
      public static void main( String args[] ){
        // create random object
        Random r = new Random();

        int[] number = new int[10];
        int count = 0;
        int num;

        while (count < number.length) {
               num = r.nextInt(21);
               boolean repeat = false;
               int i=0;

               do {
                  if (num == number[i]) {
                     repeat = true;
                  } else if (num != number[i] && i == count) {
                     number[count] = num;
                     count++;
                     repeat = true;
                  }

                  i++;

               } while (!repeat && i < number.length);
        }

        for (int j = 0; j < number.length; j++) {
               System.out.print(number[j] + " ");
        }
     } 
 }

Answer 8

这将是我的方法。

    import java.util.Random;

    public class uniquerandom {

public static void main(String[] args) {
    Random rnd = new Random();
    int qask[]=new int[10];
    int it,i,t=0,in,flag;


        for(it=0;;it++)
        {
            i=rnd.nextInt(11);
            flag=0; 
            for(in=0;in<qask.length;in++)
            {
                if(i==qask[in])
                {
                    flag=1;
                    break;
                }
            }
            if(flag!=1)
            {
                qask[t++]=i;
            }
            if(t==10)
                break;          
        }

        for(it=0;it<qask.length;it++)
            System.out.println(qask[it]);

    }}

Answer 9

public String pickStringElement(ArrayList list, int... howMany) {
    int counter = howMany.length > 0 ? howMany[0] : 1;
    String returnString = "";
    ArrayList previousVal = new ArrayList()
    for (int i = 1; i <= counter; i++) {
        Random rand = new Random()
        for(int j=1; j <=list.size(); j++){
            int newRand = rand.nextInt(list.size())
            if (!previousVal.contains(newRand)){
                previousVal.add(newRand)
                returnString = returnString + (i>1 ? ", " + list.get(newRand) :list.get(newRand))
                break
            }
        }
     }
    return returnString;
}

Answer 10

创建简单方法并在需要的地方调用-

private List<Integer> q_list = new ArrayList<>(); //declare list integer type

private void checkList(int size)
    {
        position = getRandom(list.size()); //generating random value less than size
        if(q_list.contains(position)) { // check if list contains position
            checkList(size); /// if it contains call  checkList method again
        }
        else
        {
            q_list.add(position); // else add the position in the list 
         
            playAnimation(tv_questions, 0, list.get(position).getQuestion()); // task you want to perform after getting value
        }

    }

为了获取随机值，此方法被称为-

 public static int getRandom(int max){
        return (int) (Math.random()*max);
    }