Java 计数数组中元素的出现次数

我想计算数组中的每个相同元素，这样我就可以从最高频率到最低频率进行排序。 我希望输出变成这样：

char [] array = {a,a,a,b,b,c,c,c,a,d};

4
3
2
2
1
2
1
1

我试过这个

4 (for a)
2 (for b)
3 (for c)
1 (for d)

---

我的错在哪里？

问题是您正在为字符串中的每个字符创建一个新计数器，而不是为每个可能的字母创建一个计数器。本质上，您的程序计算一个字符在当前字符之后的字符串中出现的次数

解决这个问题应该相对容易：为字母表中的每个字母创建计数器，并在看到相应的字母时增加它们。假设您能够区分大小写，您可以这样做：

char [] array = {a,a,a,b,b,c,c,c,a,d};

4
3
2
2
1
2
1
1

公共静态void CountbyChar（字符串s）{
int[]arr=新int[256]；
for（char c:s.toCharArray（））{
if（c<256）{
arr[c]++；
}
}
对于（int i=0；i！=256；i++）{
如果（arr[i]！=0）{
系统输出打印（（字符）i）；
系统输出打印（“：”）；
系统输出打印项数（arr[i]）；
}
}
}

这是因为您独立处理每个角色的位置-这意味着您仅在角色出现后计数

编辑：因为我被揍了一顿，下面是一个正确的例子：

public static void CountbyChar(String s){
    int [] arr = new int [256];
    for (char c : s.toCharArray()){
        if (c < 256) {
            arr[c]++;
        }
    }
    for (int i = 0 ; i != 256 ; i++) {
        if (arr[i] != 0) {
            System.out.print((char)i);
            System.out.print(" : ");
            System.out.println(arr[i]);
        }
    }
}

public int[]字符频率（字符串s）{
int[]频率=新int[256]；
for（char c:s.toCharArray（））{
如果（c>0&&c<256）{
频率[c]++；
}
}
返回频率；
}

您希望迭代数组并构建元素的映射，以便每个映射条目都是遇到该键的次数计数。因此，如果映射中不存在该键，请将其添加为计数1，否则使用该键的递增计数更新映射。

基本上，字符串中的每个字母都有一个计数器，您应该保留一个映射并累积每个字母的计数

这样的事情应该足够了

public int[] charFrequency(String s) {
    int[] frequencies = new int[256];
    for (char c : s.toCharArray()) {
        if (c > 0 && c < 256) {
            frequencies[c]++;
        }
    }
    return frequencies;
}

公共静态void CountbyChar（字符串s）{
HashMap letterCountMap=新的HashMap（）；
char[]c=s.toCharArray（）；
对于（int i=0；i，这里有一个简单的示例，说明如何使用贴图来实现相同的结果：

public static void CountbyChar(String s){
        HashMap<Character, Integer> letterCountMap = new HashMap<Character, Integer> ();
        char [] c =s.toCharArray();
        for (int i=0;i<c.length;i++){
            Integer count = 0;
            if (letterCountMap.containsKey(c[i])){
                count = letterCountMap.get(c[i]) + 1 ;
            }else {
                count = 1;
            }
            letterCountMap.put(c[i], count);
        }
        for (Map.Entry<String, String> entry : letterCountMap.entrySet())
        {
            System.out.println(entry.getValue() + "( for" + entry.getKey() + " )");
        }
    }

char[]inputChars={'a'，'b'，'c'，'a'，'a'，'b'，'a'，'a'}；
//创建一个映射，其键将是数组中的字符，然后
//其值将表示每个字符的次数
//在输入数组中发生。
Map countMap=新的HashMap（）；
//循环输入数组并填充映射
for（字符c:inputChars）{
if（countMap.containsKey（c））{
int currentCount=countMap.get（c）；
countMap.put（c，currentCount+1）；
}
否则{
countMap.put（c，1）；
}
}
//测试一下
for（char c:countMap.keySet（））{
打印（c+”：“+countMap.get（c））；
}

更多关于地图的阅读：


地图界面：
HashMap实现：
以下是map的实现：

char[] inputChars = { 'a', 'b', 'c', 'a', 'a', 'b', 'a', 'a' };

//  create a map whose keys will be the chars in the array and
//  whose values will represent the number of times each char 
//  occurs in the input array.

Map<Character, Integer> countMap = new HashMap<Character, Integer>();

// loop over the input array and populate the map

for (char c : inputChars) {
    if (countMap.containsKey(c)) {
        int currentCount = countMap.get(c);
        countMap.put(c, currentCount + 1);
    }
    else {
        countMap.put(c, 1);
    }
}

// test it

for (char c : countMap.keySet()) {
    print(c + ": " + countMap.get(c));
}

公共静态void countbyChar（字符串s）{
Map Map=newhashmap（）；
for（char c:s.toCharArray（））{
整数计数=map.get（c）；
如果（计数=null）{
图.put（c，1）；
}
否则{
地图放置（c，计数+1）；
}
}
对于（Map.Entry:Map.entrySet（））
{
System.out.println（entry.getKey（）.toString（）+“/”+entry.getValue（）.toString（））；
}
}
使用映射会容易得多。你可以将字符映射到它们出现的次数。如果这不是家庭作业，请告诉我……如果允许你使用映射，我会给你一个简单的例子。当然不会。我尝试学习java。这就是我来这里的原因。如果你告诉我怎么做，我会很高兴的。@jahroyAn alternative将在处理数组之前对其进行排序，以便您知道（如果当前元素与前一个元素不同）您已经计算了上一个元素的所有实例。刚刚添加了一个使用映射的简单示例的答案。我被击败了。：PJava
char
type是一个16位的Unicode代码点，而不是8位的代码。除非输入范围限制为ASCII或类似的字符，否则您的数组远远不够大。@TedHopp对，这是w为什么我添加了一个
if（c<256）
检查。在现实生活中，我可能会使用
65535
数组（毕竟，按照今天的硬件标准，256K的内存并不多）但是OP的例子强烈表明赋值使用的是UNICODE码点的ASCII子集。是的，它是有效的。但是现在我有一个新问题，如何根据频率而不是字符来打印它。@husnul创建一个包含两个字段的小类-
char ch
和
int count
，列出该类的实例，一个根据您找到的每个字符，按频率排序，然后打印结果。这是一个很好的答案，解释了如何使用自定义比较器对对象列表进行排序。在您的情况下，比较器将使用频率对象而不是
Person
对象。对于ASCII字符来说效果很好，但如果数组突然包含来自J的内容，该怎么办日语、阿拉伯语等。？