Java 使用int[]数组通过嵌套循环相互操作

我试图做的是用一种方法从0-15生成30个随机数，然后用另一种方法计算每个数字打印的次数，并将其放入第二个数组中。第二个数组中的每个位置都对应于它所在的数组中的数字。如果i=[0]和0出现3次，则应为3，依此类推

到目前为止，我已经知道了。似乎发生的事情是，它计算15次显示的次数（数组的最后一个数字）。虽然我可能错了。我不知道我做错了什么。我的逻辑一定有问题

import java.util.Arrays;

public class FrequencyOfNumbers {

    public static void main(String[]args){
        System.out.println(Arrays.toString(randomNums()));
        System.out.println(Arrays.toString(sortedNums(randomNums())));
    }

    public static int[] randomNums (){
        int[] random = new int[30];
        for(int i=0;i<random.length;i++){
           double randNum = Math.random() * 16;
            random[i] = (int)randNum;
        }
        return random;
    }

    public static int[] sortedNums(int[] sort){
        int[] numVals = new int[15];
        for(int i=0;i<numVals.length;i++)
        {
            for(int j=0;j<sort.length;j++)
            {
                if(sort[j] == numVals[i])
                {
                    numVals[i]++;
                }
            }
        }
        return numVals;
    }
}

---

要计算集合中对象的实例数，可以使用

Collections.frequency（）

：

ArrayList list=new ArrayList（）；
for（int i=0；i

要计算集合中对象的实例数，可以使用

Collections.frequency（）

：

ArrayList list=new ArrayList（）；
for（int i=0；i

代码中有一些问题：

不要调用

randomNums（）

两次。否则你就不能计算正确的频率。它将生成不同的数组

如果要将数字保持在0到15之间，则应为

numVals

分配16个元素

在计算外观时，不需要对循环使用内部

。只考虑所有的数字，取他们的价值，增加出现的数量。

试试这个：

public static void main(String[] args) {
    int[] randomNumbers = randomNums();
    System.out.println(Arrays.toString(randomNumbers));
    System.out.println(Arrays.toString(sortedNums(randomNumbers)));
}

public static int[] randomNums() {
    int[] random = new int[30];
    for (int i = 0; i < random.length; i++) {
        random[i] = (int) (Math.random() * 16);
    }
    return random;
}

public static int[] sortedNums(int[] sort) {
    int[] numVals = new int[16];
    for (int j = 0; j < sort.length; j++) {
        numVals[sort[j]]++;
    }
    return numVals;
}

---

性能

如果要计算比较次数（实际上），可以：

在类中创建新成员：

static int steps = 0;

定义增加计数器的新方法：

private static boolean f() {
    steps++;
    return true;
}

在

if

中的当前条件之前添加

f（）&&

在

main

方法中添加以下最后一行：

System.out.println(steps);

只对使用一个

，您将生成
30个步骤

使用2
for
循环（如您在评论中所写）将生成
480
步骤（
480=30*16
）

在这种情况下，这两个操作都非常快，因此不相关。但对于较大的输入，如果第一种方法需要1秒，则应注意第二种方法是否需要超过10秒。
代码中存在一些问题：

不要调用
randomNums（）
两次。否则你就不能计算正确的频率。它将生成不同的数组

如果要将数字保持在0到15之间，则应为
numVals
分配16个元素

在计算外观时，不需要对
循环使用内部
。只考虑所有的数字，取他们的价值，增加出现的数量。

试试这个：

public static void main(String[] args) {
    int[] randomNumbers = randomNums();
    System.out.println(Arrays.toString(randomNumbers));
    System.out.println(Arrays.toString(sortedNums(randomNumbers)));
}

public static int[] randomNums() {
    int[] random = new int[30];
    for (int i = 0; i < random.length; i++) {
        random[i] = (int) (Math.random() * 16);
    }
    return random;
}

public static int[] sortedNums(int[] sort) {
    int[] numVals = new int[16];
    for (int j = 0; j < sort.length; j++) {
        numVals[sort[j]]++;
    }
    return numVals;
}


性能

如果要计算比较次数（实际上），可以：

在类中创建新成员：

static int steps = 0;


定义增加计数器的新方法：

private static boolean f() {
    steps++;
    return true;
}


在
if
中的当前条件之前添加
f（）&&

在
main
方法中添加以下最后一行：

System.out.println(steps);


只对
使用一个
，您将生成
30个步骤

使用2
for
循环（如您在评论中所写）将生成
480
步骤（
480=30*16
）

在这种情况下，这两个操作都非常快，因此不相关。但是对于较大的输入，如果第一种方法需要1秒，您应该注意第二种方法是否需要10秒以上。
既然
numVals
被初始化为15个零，那么如果（sort[j]==numVals[i]）
要做什么？也许您只是想要内部循环，然后执行
numVals[sort[j]]++？你成功地让它工作了吗？实际上这对我有帮助，但我真正想要的是如果（sort[j]=I）@KylianMurphy，但是你试过答案了吗？如果
Collections
所能做的是（根据我的经验）我解决了它，那么使用嵌套for就不太可取了。那么，我应该删除这个问题还是将我的问题改为答案？我不知道协议，因为
numVals
被初始化为15个零，如果（sort[j]==numVals[I]）
要做什么？也许您只是想要内部循环，然后执行
numVals[sort[j]]++？你成功地让它工作了吗？实际上这对我有帮助，但我真正想要的是如果（sort[j]=I）@KylianMurphy，但是你试过答案了吗？如果
Collections
所能做的是（根据我的经验）我解决了它，那么使用嵌套for就不太可取了。那么，我应该删除这个问题还是将我的问题改为答案？我不知道protocolI使用的是
公共静态int[]sortedNums（int[]sort）{int[]numVals=newint[16]；例如（int i=0；iIt的工作方式似乎是相同的。出于学习目的，您可以确认或否认这一点吗？我也更改了Main方法中的数组调用。是的。此解决方案也是正确的。可能对您来说更直观，但速度没有我的快。但是，对于如此小的输入（30个数字）你看不到性能上的任何差异。好的，谢谢。我明白你的意思，它减少了打字等。我现在不担心性能差异，但我会尝试改变我的风格以融入这一点。完美。我添加了一些关于性能的细节以更好地理解这些差异。我正在使用
 公共静态int[]sortedNums（int[]sort）{int[]numVals=new int[16]；for（int i=0；iIt似乎以同样的方式工作。出于学习目的，您可以确认或拒绝此操作吗？我已更改了数组调用