Java 在arrayList中计算频率_Java

Java 在arrayList中计算频率

java

Java 在arrayList中计算频率,java,Java,下面的代码运行良好，但我想添加一个方法来计算arraylist中整数的频率。例如：90-99频率：3。。。。80-89频率6 最好的方法是什么？我应该做一个if语句来统计每个变量吗 import java.io.*; import java.lang.Math; import java.util.*; import java.text.DecimalFormat; public class gradeSorter{ public static void main(String[] args)

下面的代码运行良好，但我想添加一个方法来计算arraylist中整数的频率。例如：90-99频率：3。。。。80-89频率6

最好的方法是什么？我应该做一个if语句来统计每个变量吗

import java.io.*;
import java.lang.Math;
import java.util.*;
import java.text.DecimalFormat;

public class gradeSorter{

public static void main(String[] args) throws IOException {
{
DecimalFormat fmt = new DecimalFormat("0.000");
Scanner scanner = new Scanner(new File("grades.dat"));
double average;
double deviation;
double sum = 0;
int number = 0;
int newnumber = 0;
ArrayList<Integer> element = new ArrayList<Integer>();



while (scanner.hasNextInt())
{
element.add(scanner.nextInt());


}
for (int item : element){
        sum += item;
        System.out.println(item);
}

average = sum / element.size();

for (int i = 0; i < element.size(); i++)
{ 
newnumber += Math.pow((element.get(i) - average),2);

}


deviation = Math.sqrt(newnumber / (element.size()));




System.out.println("The average of these grades is : " + fmt.format(average));

System.out.println("The standard deviation of these grades is: " + fmt.format(deviation));  


}
}
}

首先使用一个与期望的最大值一样大的整数数组。因为这看起来像分数，也许我们可以假设你得到的最大值是100？如果是这样的话，这样的代码就可以工作了

int[] freqMap = new int[100];
for(int i=0;i<list.size();i++){
    int indexValue = list.get(i);
    freqMap[indexValue]++;
}

这是因为数组是0索引的。这里索引3的频率是10

编辑：

迭代结构以获得特定范围的频率。这是微不足道的。我将在这里演示：

//the frequency aggregate for the range 80-90
int freqFor80To90 = 0;
for(int i=80; i<90; i++){
    freqFor80To90+=freqMap[i];
}
System.out.println("The frequency for 80-90 is "+freqFor80To90);

//80-90范围内的频率聚合
int FREKFOR80到90=0；
对于（int i=80；i来说，首先使用一个与您期望的最大值一样大的整数数组。因为这看起来像是分数，也许我们可以假设您得到的最大值是100？如果是这样，那么这样的代码就可以了
int[] freqMap = new int[100];
for(int i=0;i<list.size();i++){
    int indexValue = list.get(i);
    freqMap[indexValue]++;
}

这是因为数组是0索引的。这里索引3的频率是10
编辑：
迭代结构以获得特定范围的频率。这很简单。我将在这里演示：
//the frequency aggregate for the range 80-90
int freqFor80To90 = 0;
for(int i=80; i<90; i++){
    freqFor80To90+=freqMap[i];
}
System.out.println("The frequency for 80-90 is "+freqFor80To90);

//80-90范围内的频率聚合
int FREKFOR80到90=0；
对于（int i=80；i创建一个大小为10
的数组，该数组保存每个范围内的数字频率：
int[] rangeFrequency = new int[10];

现在，对于范围-[0,9]
中的所有数字，频率将进入索引0。对于范围[10,19]
，频率将进入索引1，依此类推
现在的重点是如何获得所有这些范围的索引？以下是方法：
伪代码：
for each element in list
    bucket = element / 10   // For range [0-9], this will give index = 0
                           // For range [10-19], this will give index = 1
    rangeFrequence[bucket] += 1;

int[] rangeFrequency = new int[10];

for (int elem: element) {
    int bucket = elem / 10;
    rangeFrequency[bucket] += 1;
}

// Print frequency from array:
for (int i = 0; i < rangeFrequency.length; ++i) {
    System.out.print("Frequency in range : [" + i * 10 + ", " + 
                                                 (i * 10 + 9) + ") --> ");
    System.out.println(rangeFrequency[i]);
}


代码：
for each element in list
    bucket = element / 10   // For range [0-9], this will give index = 0
                           // For range [10-19], this will give index = 1
    rangeFrequence[bucket] += 1;

int[] rangeFrequency = new int[10];

for (int elem: element) {
    int bucket = elem / 10;
    rangeFrequency[bucket] += 1;
}

// Print frequency from array:
for (int i = 0; i < rangeFrequency.length; ++i) {
    System.out.print("Frequency in range : [" + i * 10 + ", " + 
                                                 (i * 10 + 9) + ") --> ");
    System.out.println(rangeFrequency[i]);
}

int[]rangeFrequency=新的int[10]；
for（int元素：元素）{
int bucket=elem/10；
范围频率[桶]+=1；
}
//从阵列打印频率：
对于（int i=0；i”；
System.out.println（范围频率[i]）；
}

请注意，您需要注意ArrayIndexOutOfBounds，当您的等级<0 | |等级>=100时，上述程序将崩溃。
创建一个大小为10
的数组，该数组保存每个范围内的数字频率：
int[] rangeFrequency = new int[10];

现在，对于范围-[0,9]
中的所有数字，频率将进入索引0。对于范围[10,19]
，频率将进入索引1，依此类推
现在的重点是如何获得所有这些范围的索引？以下是方法：
伪代码：
for each element in list
    bucket = element / 10   // For range [0-9], this will give index = 0
                           // For range [10-19], this will give index = 1
    rangeFrequence[bucket] += 1;

int[] rangeFrequency = new int[10];

for (int elem: element) {
    int bucket = elem / 10;
    rangeFrequency[bucket] += 1;
}

// Print frequency from array:
for (int i = 0; i < rangeFrequency.length; ++i) {
    System.out.print("Frequency in range : [" + i * 10 + ", " + 
                                                 (i * 10 + 9) + ") --> ");
    System.out.println(rangeFrequency[i]);
}


代码：
for each element in list
    bucket = element / 10   // For range [0-9], this will give index = 0
                           // For range [10-19], this will give index = 1
    rangeFrequence[bucket] += 1;

int[] rangeFrequency = new int[10];

for (int elem: element) {
    int bucket = elem / 10;
    rangeFrequency[bucket] += 1;
}

// Print frequency from array:
for (int i = 0; i < rangeFrequency.length; ++i) {
    System.out.print("Frequency in range : [" + i * 10 + ", " + 
                                                 (i * 10 + 9) + ") --> ");
    System.out.println(rangeFrequency[i]);
}

int[]rangeFrequency=新的int[10]；
for（int元素：元素）{
int bucket=elem/10；
范围频率[桶]+=1；
}
//从阵列打印频率：
对于（int i=0；i”；
System.out.println（范围频率[i]）；
}

请注意，您需要注意ArrayIndexOutOfBounds，当您的等级<0 | |等级>=100时，上述程序将崩溃。
您可以使用整数数组来实现此目的：
int[] counters = new int[NUMBER_OF_BUCKETS];

while (scanner.hasNextInt()) {
  int n = scanner.nextInt();

  // Determine which bucket this int should be in:
  int bucket = determineBucket(n);

  //Count the integer in the appropriate bucket:
  counters[bucket]++;
}

determineBucket（）
方法获取一个数字并决定应该将其计数到哪个存储桶中（一个存储桶只是一组数字，例如，在您的情况下，存储桶的范围是80-89）。对存储桶进行编码的最简单方法如下：
private static int determineBucket(int n) {
  if(80 <= n && n < 90) {
    return 0;
  } else if(90 <= n && n < 100) {
    return 1;
  } else if(...) {
    ...
  }
}

private static int determinatebucket（int n）{
如果（80您可以使用整数数组：
int[] counters = new int[NUMBER_OF_BUCKETS];

while (scanner.hasNextInt()) {
  int n = scanner.nextInt();

  // Determine which bucket this int should be in:
  int bucket = determineBucket(n);

  //Count the integer in the appropriate bucket:
  counters[bucket]++;
}

determineBucket（）
方法获取一个数字并决定应该将其计数到哪个存储桶中（一个存储桶只是一组数字，例如，在您的情况下，存储桶的范围是80-89）。对存储桶进行编码的最简单方法如下：
private static int determineBucket(int n) {
  if(80 <= n && n < 90) {
    return 0;
  } else if(90 <= n && n < 100) {
    return 1;
  } else if(...) {
    ...
  }
}

private static int determinatebucket（int n）{
如果（80见
java.util.Collections具有以下方法：
公共静态整数频率（集合c，对象o）

“返回指定集合中与指定对象相等的元素数。”
请参阅
java.util.Collections具有以下方法：
公共静态整数频率（集合c，对象o）

“返回指定集合中与指定对象相等的元素数。”
是的，让我来编辑…您可以使用整数数组，但它对方差较大的数据不起作用。@James您已经使用了ArrayList
，所以该学习了；-）@William Morrison，如果你不介意的话，你可以发布int数组方法，这样我就可以看到它是如何完成的。这不会找到范围的频率，而是每个元素的频率。对，Jason和我建议相同的事情，除了我使用的桶大小为1，他使用的桶大小为10。他正在计算一个可以立即容纳你的解的结构，我正在创建一个structure您需要查询解决方案。这是我在回答的最后演示的内容。是的，让我编辑一下……您可以使用整数数组，但它对高方差的数据不起作用。@James您已经使用了ArrayList
，所以现在是学习的时候了；-）@William Morrison，如果你不介意的话，你可以发布int数组方法，这样我就可以看到它是如何完成的。这不会找到范围的频率，而是每个元素的频率。对，Jason和我建议相同的事情，除了我使用的桶大小为1，他使用的桶大小为10。他正在计算一个可以立即容纳你的解的结构，我正在创建一个struC您需要查询解决方案。这是我在回答末尾演示的。如果所有数字都<100，您可以创建一个int[100]
并存储每个数字的频率。或一个int[10]
存储每个x0-x9范围。@詹姆斯，不要删除代码。重要的是提供问题和答案的上下文。如果所有数字都<100，你可以创建一个int[100]