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

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

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

我试过这个

public static void CountbyChar(String s){
    int [] arr = new int [s.length()];
    char [] c =s.toCharArray();
    for (int i=0;i<c.length;i++){
        arr[i]=1;
        for (int j=i+1;j<c.length;j++){
            if(c[i]==c[j]){
                arr[i]++;
            }
        }
    }
    for (int x:arr){
        System.out.println(x);
    }
}

但我得到了：

4
3
2
2
1
2
1
1

我的错在哪里？

4

6 回答 6

3

Here's a simple example of how to use a Map to achieve the same result:

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));
}

More reading on Maps:

于 2012-12-17T22:54:51.393 回答
3

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

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

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]);
        }
    }
}
于 2012-12-17T22:42:58.873 回答
1

You are basically having a counter for each letter in the string, you should keep one Map and accumulate the count for each letter.

Something like this should be sufficient

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() + " )");
        }
    }
于 2012-12-17T22:54:19.613 回答
1

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

于 2012-12-17T22:44:04.600 回答
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;
}
于 2012-12-17T22:43:28.433 回答
0

这是使用地图的实现：

public static void countbyChar(String s){
    Map<Character, Integer> map = new HashMap<Character,Integer>();

    for (char c : s.toCharArray()){
         Integer count = map.get(c);
         if (count == null) {
            map.put(c, 1);
         }
         else {
            map.put(c, count + 1);
         }
    }

    for (Map.Entry<Character, Integer> entry : map.entrySet())
    {
        System.out.println(entry.getKey().toString() + "/" + entry.getValue().toString());
    }
}
于 2012-12-17T23:12:17.420 回答