到目前为止，这是我尝试过的：
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
我遇到了这个问题。我需要你的帮助。感谢。
答案 0 :(得分：6)
这将是最快的方式：
final int[] counts = new int[1<<16];
for (char c : <your_string>)
counts[c]++;
（我刚刚勾勒出迭代你所有字符的部分，我相信这很容易，而且与这个问题没有直接关系）。
我用HashMap方法对付我的三个弦长：
这些是结果：
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。
答案 1 :(得分：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);
}
}
答案 2 :(得分：2)
我相信使用基元会比使用HashMap更快。 This works：
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.
答案 3 :(得分：1)
正如评论中所提到的，HashMap似乎是理想的，虽然我不会给你直接代码，但我会给你一个pseduo代码模板。
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
答案 4 :(得分：1)
我建议你创建一个TreeSet然后你可以有一个新的类来存储字符和ocurrences的数量，然后你可以让那个类有一个compareTo来检查事件，一个equals来检查char。然后，无论何时将它们插入树集中，它们将始终按照最多出现的顺序排列。
如果您需要帮助，或者如果您能通过以下信息弄明白，请告诉我们。）
编辑：一旦你用所有字母填充了TreeSet，你所要做的就是开始逐一取出它们，直到你取出的那个小于你之前的那个（即，如果前3个字母出现3次而第4个出现2，则只显示前3个字母。
答案 5 :(得分：0)
你必须拿一个HashMap来保留重复时间最多的字符并打印出来。
答案 6 :(得分：0)
你需要做的是取文字（字符串）。并查看它的每个字符并将其放入适当的桶中。换句话说，你需要对它们进行分组。
您可以为每个字母表创建一个存储桶。然后你可以将char放在适当的桶中，最后计算其中的项目以获得答案。
见Marko回答，这样做。
另一个选择是您对文字AHIIMSS进行排序，然后使用简单循环，您将能够编写结果。
您选择的方法取决于您需要获得的结果。如果你需要找到在单词中使用的每个字母的数量，那么排序选项更潮，如果你只需要选择最大字母，那么使用存储桶解决方案会更有用。
答案 7 :(得分：0)
import java.util。*;
公共类CharacterCounter {
public static void main（String [] args）{
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);
}
} }
答案 8 :(得分：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);
答案 9 :(得分：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
* /
答案 10 :(得分：-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 pattern = Pattern.compile("i");
Matcher matcher = pattern.matcher("saigigd");
int count = 0;
while (matcher.find())
count++;
System.out.println(count);