生成非重复数字的随机二维数组，Java

用户将键入i（变量）的数字，然后键入j（每个变量的元素）的数字，最后键入可能的最大值（maxelm）。 使用输入的值，任务是生成非重复随机数（变量中的非重复，表示i，但数字可能在整个数组中重复）

例如，给出输入3（i）、5（j）、9（maxElem）的成功输出将是：

private static void modified(int[][] greatLoto) {
Random r = new Random(System.currentTimeMillis());
    for (int i = 0; i < greatLoto.length; i++) {
        for (int j = 0; j < greatLoto[i].length; j++) {
            do {
                greatLoto[i][j] = r.nextInt(maxElem);
            } while (Arrays.asList(greatLoto[i]).contains(greatLoto[i][j]));    
        }
        System.out.println("");
    }

}

4| 8 | 1 | 7 | 9

3 | 8 | 2 |45

2 | 6 |48 | 5

您可能会注意到，数字4在整个阵列中重复3次（允许）。但是，对于i=0，数字4是唯一的

请告诉我此代码的更改：

静态扫描仪sc=新扫描仪（System.in）

静态int-maxelm

public static void main(String[] args) {

    int[][] greatLoto;

    System.out.println("Of how many variants will the ticket consist?  ");
    int variants = sc.nextInt();

    System.out.println("Of how many elements will the variants consist? ");
    int elements = sc.nextInt();

    System.out.println("Which value should be considered the maximum value? ");
    maxElem = sc.nextInt() + 1;

    greatLoto = new int[variants][elements];

    System.out.println("Initial values: ");
    show(greatLoto);

    System.out.println("Modifying values...");
    modified(greatLoto);

    System.out.println("Newest values: ");
    show(greatLoto);

}

private static void show(int[][] greatLoto) {
    for (int i = 0; i < greatLoto.length; i++) {
        for (int j = 0; j < greatLoto[i].length; j++) {
            System.out.print("|" + greatLoto[i][j] + "|");
        }
        System.out.println("");
    }
    System.out.println("");
}

private static void modified(int[][] greatLoto) {
Random r = new Random(System.currentTimeMillis());
    for (int i = 0; i < greatLoto.length; i++) {
        for (int j = 0; j < greatLoto[i].length; j++) {

            while (Arrays.asList(greatLoto[i]).contains(r)) {
               r = new Random(System.currentTimeMillis());
            }
            greatLoto[i][j] = r.nextInt(maxElem);;

        }
        System.out.println("");

    }

}

publicstaticvoidmain（字符串[]args）{
int[]greatLoto；
System.out.println（“票证将包含多少变体？”）；
int variants=sc.nextInt（）；
System.out.println（“变量将包含多少个元素？”）；
int elements=sc.nextInt（）；
System.out.println（“哪个值应该被认为是最大值？”）；
maxElem=sc.nextInt（）+1；
greatLoto=新的int[变体][元素]；
System.out.println（“初始值：”）；
表演（greatLoto）；
System.out.println（“修改值…”）；
改良（greatLoto）；
System.out.println（“最新值：”）；
表演（greatLoto）；
}
私有静态无效显示（int[][]greatLoto）{
for（int i=0；i

您需要三个循环：

循环1:构建一个大小为

j

的数组，并对该数组的每个字段使用循环1B

Loop_1B:使用

r.nextInt（maxElem）+1生成一个int

（必须是

+1

，因为

nextInt（）

包含0且仅包含指定值）。然后检查数组中是否已经使用了该数字，如果是，请再次运行此循环

---

循环\u 2:重复循环\u 1

i

次。

这更多是一个注释，但太长：不要使用random.next（），因为它会强制您检查唯一性。而是用有效值填充列表并将其洗牌：

List<Integer> values = new ArrayList<> ();
for (int i = 1; i <= max; i++) values.add(i);
Collections.shuffle(values);

List values=newarraylist（）；
对于（int i=1；i而言，最微小的变化是：

private static void modified(int[][] greatLoto) {
Random r = new Random(System.currentTimeMillis());
    for (int i = 0; i < greatLoto.length; i++) {
        for (int j = 0; j < greatLoto[i].length; j++) {
            do {
                greatLoto[i][j] = r.nextInt(maxElem);
            } while (Arrays.asList(greatLoto[i]).contains(greatLoto[i][j]));    
        }
        System.out.println("");
    }

}

private static void已修改（int[]greatLoto）{
Random r=新的Random（System.currentTimeMillis（））；
for（int i=0；i

但是有更优雅（但很难编码）的方法来生成唯一的随机数，而不丢弃重复数。
您应该提到，只有当max非常小时，这才是合理的。它必须是
r.nextInt（maxElem）+1；
因为OP希望包含
maxElem
。。。