0

到目前为止，这是我尝试过的：

public class CharacterCounter {

public static void main(String[] args){

    String string = "sashimi";

    int count = 0;
    for(int i =0; i < string.length(); i++){
        if(string.charAt(i) == 'i'){
            count++;
            }
    }

    System.out.println("The number of letter i is " + count);

} 
}

输出：

 The number of letter i is 2

但我想做的是，程序应该计算出现次数最多的字符。

例如这里的字符串是SASHIMI，输出应该是：

 the number of letter S is 2
 the number of letter I is 2

我被这个问题困住了。我需要你的帮助。谢谢。

4

11 回答 11

7

这将是最快的方法：

final int[] counts = new int[1<<16];

for (char c : <your_string>)
  counts[c]++;

（我刚刚勾勒出迭代所有字符的部分，我相信这是简单的部分，与这个问题没有直接关系）。

基准测试结果

我已经HashMap用三种字符串长度将这种方法与我的方法进行了对比：

  1. 10
  2. 1,000
  3. 100,000

这些是结果：

Benchmark       Mode Thr    Cnt  Sec         Mean   Mean error    Units
testArray1      thrpt   1      5    5        6.870        0.083 ops/msec
testArray2      thrpt   1      5    5        6.720        0.374 ops/msec
testArray3      thrpt   1      5    5        3.770        0.019 ops/msec
testHashMap1    thrpt   1      5    5     1269.123      251.766 ops/msec
testHashMap2    thrpt   1      5    5       12.776        0.165 ops/msec
testHashMap3    thrpt   1      5    5        0.141        0.005 ops/msec

他们的意思是什么？是的，将一个完整的 512K 内存块初始化为零是昂贵的。但是在付费之后，我的数组算法甚至几乎没有注意到成千上万的字符呼啸而过。HashMap另一方面，这种方法对于非常短的字符串要快得多，但扩展性要差得多。我猜分频器的字符串长度约为 2k。

我想这样的字符数统计通常是针对大量文本语料库而不是像你的名字和姓氏这样的东西运行的，这一点没有争议。

当然，如果您可以假设不使用完整的 UTF-16 代码点范围，则可以显着提高数组方法的性能。例如，如果您使用仅包含最低 1024 个代码点的数组，则性能将提高到 470 ops/msec。

于 2013-08-01T13:15:16.783 回答
4 
    char[] chars = string.toCharArray();
    HashMap<Character, Integer> countMap = new HashMap<Character, Integer>();
    for (char aChar : chars) {
        if (countMap.containsKey(aChar)) {
            countMap.put(aChar, countMap.get(aChar) + 1);
        } else {
            countMap.put(aChar,1);
        }
    }

    //determine max occurence
    int max = 0;
    for (Integer i: countMap.values()) {
        if (max < i) {
            max = i;
        }
    }

    //print all satisfiying max occurrence
    for (Map.Entry<Character, Integer> e: countMap.entrySet()) {
        if (e.getValue() == max) {
            System.out.println("The number of letter " + e.getKey() + "  is " + max);
        }
    }
于 2013-08-01T13:18:45.700 回答
2

我相信使用原语会比使用HashMap. 这有效：

public static void main(String[] args)
{
    final String string = "sashimi";
    final int counters[] = new int[256]; // assuming you would use only ASCII chars
    for (final char c : string.toCharArray())
    {
        counters[c]++;
    }
    int maxCounter = 0;
    for (final int counter : counters)
    {
        if (maxCounter < counter)
        {
            maxCounter = counter;
        }
    }
    for (int i = 0; i < counters.length; i++)
    {
        if (counters[i] == maxCounter)
        {
            System.out.printf("%c has %d occurences.\n", i, counters[i]);
        }
    }
}

输出：

i has 2 occurences.
s has 2 occurences.
于 2013-08-01T13:33:07.490 回答
1

正如评论中提到的，aHashMap似乎很适合这个，虽然我不会给你直接的代码，我会给你一个伪代码模板。

for(each letter in a word)
{
    if(this letter (l) exists in your hash map)
    {
         hashmap.put(l, hashmap.get(l) ++);
    }
    else
    {
         hashmap.put(l, 1);
    }
}

这将为您提供所有字母的哈希图，映射到它们在单词中出现的次数。按照你的例子：

S => 2
A => 1
H => 1
I => 2
M => 1
于 2013-08-01T13:15:09.493 回答
1

我建议你创建一个 TreeSet，然后你可以有一个新的类来存储字符和出现次数，然后你可以让那个类有一个 compareTo 来检查出现和一个 equals 来检查字符。然后，每当您将它们插入树集中时，它们将始终按照出现次数最多的顺序排列。

如果您需要这方面的帮助，或者您是否可以通过此信息解决问题，请告诉我 :)

编辑：一旦你用所有的字母填充了 TreeSet，你所要做的就是开始一个一个地把它们取出来，直到你取出的那个的出现次数少于你之前取出的那个（即，如果前 3 个字母出现 3 次，第四个字母出现 2 次，您只显示前 3 个）。

于 2013-08-01T13:23:00.453 回答
0

您必须使用HashMap重复时间来保留重复次数最多的字符并打印它。

于 2013-08-01T13:12:45.507 回答
0

您需要做的是获取文字（字符串）。并查看它的每个字符并将其放入适当的桶中。换句话说，您需要将它们分组。

您可以为每个字母创建一个存储桶。然后，您可以将 char 放入适当的桶中，最后计算其中的项目以获得答案。

请参阅 Marko 的答案，即这样做。

另一种选择是您对文字进行排序AHIIMSS，然后使用简单的循环您将能够编写结果。

您选择的方法取决于您需要获得的结果。如果您需要找出每个字母在 word 中使用的数量，那么排序选项会更流行，如果您只需要选择最大的字母，那么使用桶的解决方案会更有用。

于 2013-08-01T13:18:17.917 回答
0

导入 java.util.*；

公共类 CharacterCounter {

公共静态无效主要（字符串[]参数）{

String string = "sashimi";
int count = 0;
ArrayList<Character> c = new ArrayList<Character>();
for(int i =0; i <string.length(); i++)
{
    count=0;
    if(c.contains(string.charAt(i)))
    {
        continue;
    }   
    c.add(string.charAt(i));        
    for(int j = 0;j<string.length();j++)
    {

        if(string.charAt(j) == string.charAt(i))
        {

            count++;

        }


    }
    System.out.println("The number of letter "+string.charAt(i)+" is " + count);
}

} }

于 2013-08-01T13:33:47.120 回答
0 
    String str = "sashimi";
    Map<Character,Integer> countMap=new HashMap<Character,Integer>();
    Set<Character> maxcSet=new HashSet<Character>();
    Character maxC=null;
    Integer maxCount=null;
    for (int i = 0; i < str.length(); i++) {
        char c=str.charAt(i);
        Integer tempCount=countMap.get(c);

        if(tempCount==null){
            tempCount=0;
        }

        ++tempCount;

        if(i==0){
            maxCount=tempCount;
            maxC=c;
        }else if(tempCount!=null){
            if(maxCount<tempCount){
                maxC=c;
                maxCount=tempCount;
                maxcSet.clear();
                maxcSet.add(maxC);
            }else if(maxCount==tempCount){
                maxcSet.add(c);
            }
        }
        countMap.put(c, tempCount);
    }

    System.out.println("The number of letter i is " + maxcSet);
于 2013-08-01T15:17:49.913 回答
0 
import java.util.Scanner;


public class CountingCharecter {
public static void main(String[] args) throws Exception {
    ///Reading Data String from keyboard
    int count=0;
    System.out.println("Enter Your String:");
    Scanner sc = new Scanner(System.in);
    String s1 = sc.nextLine();
    //// Reading `Character` Data from Keyboard
    System.out.println("Enter an character:");
    //Here we read the character from console type cast the character because the read() return type is int
    char ch =(char)System.in.read();
    for(int i=0;i<s1.length();i++){
           char c = s1.charAt(i);
           if(c==ch){
               count++;
           }//if


    }//for
    System.out.println("The Number of character which you want to search is having: "+count+" Times");
}
}//CharecterCount
/*

输入：- 输入您的字符串：Manash 输入一个字符：a 输出：- 2

*/

于 2015-09-27T15:44:18.497 回答
-1 
 public static int numberOfOccurence(String yourString, char needle) {
      int nb = 0;
      for (int i=0; i < yourString.length(); i++)
    {
        if (yourString.charAt(i) == needle)
                   nb++;

    }
    return nb;
}

您还可以使用 Pattern 和 Matcher ：

   Pattern pattern = Pattern.compile("i");
   Matcher  matcher = pattern.matcher("saigigd");

   int count = 0;
   while (matcher.find())
   count++;
   System.out.println(count);
于 2013-08-01T13:13:23.550 回答