Question

我是编程的新手，我刚开始做一个程序，我想生成并排序20个独特的随机数，但我怎么只能生成不唯一的数字，也不能使用这个脚本排序

import java.util.Random;

class FTW {
    public static void main (String[]args){
        Random I  = new Random();
        int number; 

        for(int counter=1; counter<=20;counter++){
            number = I.nextInt(20);
            System.out.println(number + " ");
        }
    }
}

任何人都可以帮我编辑这个或者可以给我一个更好的工作，并在可能的情况下向我解释：）

Answer 1

使用HashSet将保留唯一性

这将提供一组随机的20个数字，来自1-50

  public static void main(final String[] args){
        final Random random = new Random();
        final Set<Integer> intSet = new HashSet<>();
        while (intSet.size() < 20) {
            intSet.add(random.nextInt(50) + 1);
        }
        final int[] numbers = new int[intSet.size()];
        final Iterator<Integer> iter = intSet.iterator();
        for (int i = 0; iter.hasNext(); ++i) {
            numbers[i] = iter.next();
        }
        System.out.println(Arrays.toString(numbers));
    }

Answer 2

一种方法是将数字添加到ArrayList并检查它是否包含while循环中的下一个随机数。（这些是从0到100的20个唯一随机数）

public class FTW {
    public static void main (String[]args){
        Random I  = new Random();
        List<Integer> list = new ArrayList<Integer>();
        int number; 

        for(int counter=1; counter<=20;counter++){
            number = I.nextInt(100);
            while(list.contains(number)) {
                number = I.nextInt(100);
            }
            list.add(number);
        }
        Collections.sort(list); //Sorts the list
        System.out.println(list);
    }
}

Answer 3

您可以按照以下步骤操作：
1。维持ArrayList以存储生成的唯一随机数（uniqueSortedRandoms）。
2。在此newNumber中插入新号码ArrayList时，请检查数组uniqueSortedRandoms是否包含newNumber以及newNumber }大于或等于前一个。我假设数组按升序排序。请参阅以下代码 -

import java.util.Random;

class FTW {
    public static void main (String[]args){
        Random I  = new Random();
        int newNumber;
        List<Integer> uniqueSortedRandoms = new ArrayList<Integer>();


        for(int counter=1; counter<=20;){

            int previousNumber = -1 // initially set to -1
                                    // because nextInt() can be 
                                    //range from 0 (inclusive) to 20 exclusive
            newNumber = I.nextInt(20);

            if(newNumber>previousNumber && !unqueSortedRandoms.contains(newNumber)){

               uniqueSortedRandoms.add(newNumber);
               previousNumber = newNumber;
               counter++;  
            }

            System.out.println(number + " ");
        }
    }
}

现在ArrayList - uniqueSortedRandoms包含您按升序排列的所有唯一随机数。

注意：
1。如果您使用random.nextInt(20)，则会生成从0到20的独立的随机数。并且您需要按排序顺序排列20个随机数。因此，数组列表实际上包含从0到19的20个数字。在这种情况下，您可以生成arrayList，其数字从0到19.如果您需要按排序顺序排列20个随机数（不在0到0范围内） 19）像[3,4,9,10，......]那么你可以使用一个非常大的int作为nextInt(int n)的参数 -

newNumber = I.nextInt(100);

现在每个newNumber都在范围内 - 0<=newNumber<100。因此，您的数组将按升序包含20个唯一的随机数。

2. counter在if-block内递增（当新生成的随机数插入ArrayList时），以便循环继续我们得到第20个随机数。

Answer 4

如何在不排序的情况下生成唯一的排序数字。您可以创建布尔数组和您选择的数字，该索引为真。

public static void main(String[] args) {
        int maxNumber = 150;
        int totalCount = 20;        
        Random random = new Random();

        boolean[] generatedNumbers = new boolean[maxNumber];
        int generatedCount = 0;

        while (generatedCount < totalCount){
            int newNumber = random.nextInt(maxNumber);
            if (generatedNumbers[newNumber] == false){
                generatedNumbers[newNumber] = true;
                generatedCount++;
            }
        }

        int[] sortedUniqueArray = new int[totalCount];

        int selectedNumbers = 0;
        for (int i = 0; i < generatedNumbers.length; i++) {
            if (generatedNumbers[i] == true){
                sortedUniqueArray[selectedNumbers] = i;
                selectedNumbers++;                
            }
        }

        System.out.println(Arrays.toString(sortedUniqueArray));
    }

此示例的输出为：

[6, 19, 33, 47, 51, 53, 71, 75, 82, 86, 89, 92, 105, 108, 121, 125, 126, 137, 140, 147]

如何使用Java生成20个带有订单的唯一随机数？

4 个答案: