Java 2个阵列随机显示1-10和随机显示1-10，无功能

这个程序的目标是让A2[]以随机顺序显示数字1-10。它需要在没有任何基础知识的情况下完成。A2[]从A1[]获取数字，A1[]数组按顺序存储数字1-10。在当前状态下，程序运行，但不过滤已存储在A2[]中的结果。例如4,2,3,7,5,9,7,1,4不应该是结果。只能显示1-10的随机顺序，每个int只出现一次。非常感谢您的帮助。现行守则如下：`

public class W07problem07 {

    public static int getRandomIntRange(int min, int max) {
        int x = (int) (Math.random() * ((max - min))) + min;
        return x;
    }

    public static void main(String[] args) {
        int ranNum;
        int count = 1;
        int[] A1 = new int[10];
        int[] A2 = new int[10];

        //loop for storing 1-10 int number withing  A1[].
        for (int k = 0; k < A1.length; k++) {
            A1[k] = count;
            count++;
        }
        for (int k = 0; k < A2.length; k++) {
            A2[k] = k;
        }

        for (int j = 0; j < A2.length; j++) {
            int a;
            ranNum = getRandomIntRange(0, A2.length);
            a = A2[j];
            if(a==ranNum){
                j--;
            } else{
                A2[j]= A1[ranNum];
            }
        }



        for (int k = 0; k < A2.length; k++) {
            System.out.println(A2[k]);
        }
    }
}
`

公共类W07问题07{
公共静态int getRandomIntRange（int最小值，int最大值）{
intx=（int）（Math.random（）*（（max-min））+min；
返回x；
}
公共静态void main（字符串[]args）{
int ranNum；
整数计数=1；
int[]A1=新的int[10]；
int[]A2=新的int[10]；
//使用A1[]存储1-10整数的循环。
对于（int k=0；k

有很多方法可以满足你的要求

最简单的方法之一是应用哈希理论，使用下一个未调用的数字作为下一个（伪）随机数。
我假设你在代码中写的东西没有多大意义，所以接下来，我假设A1中填充了数字1-10，而A2中直接填充了随机数字

示例：
这是A2的当前状态。下一个随机数为1，但如果已经拾取，则该值不好

A1   |1 2 3 4 5 6 7 8 9 10|
A2   |1 4 7 9 . . . . . . |

因此，当发现“冲突”时，继续应用此修复：
新的随机数变为x=x+1，直到取下未勾选的数字

所以

正如您可以想象的，您可以使用很多冲突策略，前一个策略称为开放寻址。

还有一个解决方案

public class W07problem07 {
    public static int getRandomIntRange(int min, int max) {
        int x = (int) (Math.random() * ((max - min))) + min;
        return x;
    }
    public static void main(String[] args) {
        int count = 1;
        int[] A1 = new int[10];
        int[] A2 = new int[10];
        //loop for storing 1-10 int number withing  A1[].
        for (int k = 0; k < A1.length; k++) {
            A1[k] = count;
            count++;
        }
        int j = 0;
        while (j < A1.length) {
            int ranNum = getRandomIntRange(1, A1.length + 1);
            if (!numAlreadyExists(A2, ranNum)) {
                A2[j++] = ranNum;
            }
        }
        for (int k = 0; k < A2.length; k++) {
            System.out.println(A2[k]);
        }
    }
    public static boolean numAlreadyExists(int[] array, int element) {
        for (int i = 0; i < array.length; i++) {
            if (element == array[i]) {
                return true;
            }
        }
        return false;
    }
}

公共类W07问题07{
公共静态int getRandomIntRange（int最小值，int最大值）{
intx=（int）（Math.random（）*（（max-min））+min；
返回x；
}
公共静态void main（字符串[]args）{
整数计数=1；
int[]A1=新的int[10]；
int[]A2=新的int[10]；
//使用A1[]存储1-10整数的循环。
对于（int k=0；k

它的相似项可能重复，但我只能使用A1[]和A2[]。这是类的一个Hw，我们还没有讨论过该线程中的任何内容。因为源数组中只有1-10之间的数字，所以可以用这个范围之外的数字填充目标数组，如-1（这称为哨兵值）。然后，对于源数组中的每个数字，选择一个随机目标数组索引并检查它是否可用（其中有-1）。继续选择一个新的索引，直到找到一个可用的位置。哦！！！我没有想到这一点。我现在就来试试，看看效果如何。谢谢这可能会输出当前所需的输出。但是在代码中，您没有使用

A1

数组。如果

A1

包含例如从11到20的数字，您的解决方案仍将打印数字1到10。

public class W07problem07 {
    public static int getRandomIntRange(int min, int max) {
        int x = (int) (Math.random() * ((max - min))) + min;
        return x;
    }
    public static void main(String[] args) {
        int count = 1;
        int[] A1 = new int[10];
        int[] A2 = new int[10];
        //loop for storing 1-10 int number withing  A1[].
        for (int k = 0; k < A1.length; k++) {
            A1[k] = count;
            count++;
        }
        int j = 0;
        while (j < A1.length) {
            int ranNum = getRandomIntRange(1, A1.length + 1);
            if (!numAlreadyExists(A2, ranNum)) {
                A2[j++] = ranNum;
            }
        }
        for (int k = 0; k < A2.length; k++) {
            System.out.println(A2[k]);
        }
    }
    public static boolean numAlreadyExists(int[] array, int element) {
        for (int i = 0; i < array.length; i++) {
            if (element == array[i]) {
                return true;
            }
        }
        return false;
    }
}