Java 计算字符串中每个字母的出现次数

我知道这个话题以前已经讨论过了，但是我没有找到我需要的。我试图数一数字母表中每个字母的出现次数；来自用户输入的字符串。输出将包括所有26个字母，即使它们没有出现。因此，0将被分配给未出现的字母。我通过循环一系列字母表并将其与用户输入进行比较来实现这一点

我在添加字母和显示每个字母时遇到问题。我的输出结果是显示输入的每个字母+1

    public class TwoArrays {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        char[] lower = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        char[] upper = new char[] {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};

        System.out.println("Please enter a sentence to parse.");
        String userString = input.nextLine();

        for(int i = 0; i < userString.length(); i++) {
            //lowercase
            for(int l = 0; l < lower.length; l++) {
                int counter = 0;
                if(lower[l] == userString.charAt(i)) {
                    counter++;
                    System.out.println(lower[l] + ":" + counter);
                }
            }   
            //uppercase
            for(int u = 0; u < upper.length; u++) {
                int counter = 0;
                if(upper[u] == userString.charAt(i)) {
                    counter++;
                    System.out.println(upper[u] + ":" + counter);
                }
            }
        }
    }
}

---

以下是英文字母计数应用程序的不区分大小写版本：

public static void main(final String[] args) {
    System.out.println("Please enter a sentence to parse.");
    try (final Scanner input = new Scanner(System.in)) {
        final String userString = input.nextLine();

        final long[] symbols = new long[26];
        for (final char c : userString.toCharArray()) {
            if ((c >= 'a') && (c <= 'z')) {
                symbols[c - 'a']++;
            } else if ((c >= 'A') && (c <= 'Z')) {
                symbols[c - 'A']++;
            }
        }
        for (int i = 0; i < 26; i++) {
            System.out.println((char) ('a' + i) + ": " + symbols[i]);
        }
    }
}

---

使用增强的loop+

HashMap

，您可以统一两个包含字符的数组：

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    char[] array = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
            'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};

    System.out.println("Please enter a sentence to parse.");
    String userString = input.nextLine();

    HashMap<Character, Integer> charint = new HashMap<>();

    for (Character c : userString.toCharArray()){
        if (charint.containsKey(c)) charint.replace(c, charint.get(c).intValue() + 1);
        else charint.put(c, 1);
    }

    for (int i = 0 ; i < array.length ; i++){
        System.out.println(array[i] + " : " + (charint.get(array[i]) == null ? "0" : charint.get(array[i])));
    }
}

这里有一个使用的方法。由于您不想在字符串中显示

0

到

char

，因此我们可以首先

将
所有字符放入
映射中。然后我们可以在字符串上迭代并增加找到的字符的
值

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

for (Character c: "abcdefghijklmnopqrstuvwxyz".toCharArray()) {
    charMap.put(c, 0);
}

for (Character c: test.toCharArray()) {
    if (charMap.containsKey(c)) {
        charMap.put(c, charMap.get(c) + 1);
    }
}

Map charMap=newhashmap（）；
for（字符c:“abcdefghijklmnopqrstuvxyz”.toCharArray（））{
charMap.put（c，0）；
}
for（字符c:test.toCharArray（））{
if（charMap.containsKey（c））{
charMap.put（c，charMap.get（c）+1）；
}
}

使用谷歌番石榴，您可以摆脱不必要的样板文件，并在一行中计算区分大小写的直方图（使用
input.toLowerCase（）.toCharArray（）
区分大小写）：

String input=“hello WORLD”；
多集直方图=HashMultiset.create(
asList（input.tocharray（））；

直方图可以按如下方式输出：

public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
//...
final List<Character> caseSensitiveAlphabet 
    = Lists.newArrayList(Chars.asList(ALPHABET.toCharArray()));
caseSensitiveAlphabet.addAll(
    Chars.asList(ALPHABET.toUpperCase().toCharArray()));

for (char c : caseSensitiveAlphabet) {
    System.out.println(c + " : " + histogram.count(c));
}

    String input = "Hello WORLD";

    Map<Character, Integer> map = new TreeMap<>();

    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
            .chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.put(c, 0));

    input.chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.computeIfPresent(c, (k, v) -> v + 1));

    System.out.println(map);

public static final String ALPHABET=“abcdefghijklmnopqrstuvxyz”；
//...
最终清单案例敏感阿尔法贝
=Lists.newArrayList（Chars.asList（ALPHABET.toCharArray（））；
区分大小写alphabet.addAll(
字符列表（ALPHABET.toUpperCase（）.toCharArray（））；
用于（字符c：区分大小写的对话框）{
System.out.println（c+“：“+直方图.计数（c））；
}
公共静态void main（字符串参数[]）{
//将下方和上方阵列转换为一个新的上方和下方贴图
//char[]lower=new char[]{'a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'u'，'v'，'w'，'x'，'y'，'z'}；
//字符[]上限=新字符[]{'A'、'B'、'C'、'D'、'E'、'F'、'G'、'H'、'I'、'J'、'K'、'L'、'M'、'N'、'O'、'P'、'Q'、'R'、'S'、'T'、'U'、'V'、'W'、'X'、'Y'、'Z'}；
Map countMap=newtreemap（）；
整数计数；
字符串inputStr=“Hello WORLD”；
char[]arr=inputStr.toCharArray（）；
for（字符c:arr）{
计数=0；
如果（c=''）
继续；
if（countMap.containsKey（c））
count=countMap.get（c）；
countMap.put（c，count+1）；
}
迭代器it=countMap.entrySet（）.Iterator（）；
while（it.hasNext（））{
Map.Entry对=（Map.Entry）it.next（）；
System.out.println（pair.getKey（）+“=”+pair.getValue（））；
it.remove（）；//避免ConcurrentModificationException
/*选中pair.getKey（）包含在上下映射中，如果包含分配新的
将价值转化为地图*/
}
//最后循环上下映射以显示字符出现
}

认为这会对您有所帮助。
在Java 8中，您可以解决以下问题：

public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
//...
final List<Character> caseSensitiveAlphabet 
    = Lists.newArrayList(Chars.asList(ALPHABET.toCharArray()));
caseSensitiveAlphabet.addAll(
    Chars.asList(ALPHABET.toUpperCase().toCharArray()));

for (char c : caseSensitiveAlphabet) {
    System.out.println(c + " : " + histogram.count(c));
}

    String input = "Hello WORLD";

    Map<Character, Integer> map = new TreeMap<>();

    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
            .chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.put(c, 0));

    input.chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.computeIfPresent(c, (k, v) -> v + 1));

    System.out.println(map);

String input=“Hello WORLD”；
Map Map=newtreemap（）；
“ABCDEFGHIjklmnopqrstuvwxyzABCDEFGHIjklmnopqrstuvxyz”
.chars（）
.mapToObj（i->（char）i）
.forEach（c->map.put（c，0））；
input.chars（）
.mapToObj（i->（char）i）
.forEach（c->map.computeIfPresent（c，（k，v）->v+1））；
系统输出打印项次（map）；

这将产生：

0，G=0，I=0，J=0，K=0，K=0，p=0，N=0，p=0，B=0，p=0，B=0，p=0，B=0，B=0，B=0，N=0，N=0，O=0，O=0，p=0，B=0，B=0，B=0，B=0，B=0，p=0，N=0，0，0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=0，O=1，O=1，p=1，p=1，p=1，p=0，p=0，p=0，p=0，p=0，p=0，p=0，p=0，p=0 V=0，W=0，X=0，Y=0，Z=0}
这里是不使用任何包的最简单答案

这里我有一个字符串，首先我将这个字符串转换成字符，然后我运行一个循环来计算这个字符中的字母数

由于每个字母至少出现一次，所以我将1分配给标志c，该标志c存储每个字母出现的次数

现在我运行嵌套循环来检查一个字母表是否出现了不止一次。如果出现了，我将标志c增加1，然后从k=j运行第三个嵌套循环来删除这个重复的字母表

这里j是重复字母表的索引，为了删除这个字母表，我在下一个（j+1）索引处给这个（j）索引赋值，在索引j+2处给索引j+1……赋值，依此类推，直到我到达n-1索引处，它现在是第n个索引的赋值

删除这个重复的字母表后，字符的大小减少了1，所以我将n减少了1

    public class AlphabetOccurance {
public static void main(String[] args) {
    String s;
    s = "ASGFDTRRCJFYDCJHGJ";
    char ch[] = s.toCharArray(); // converted string to chararray       
     int i,j,k,c=1,n;
     for (i=0; i<s.length();i++); // loop to find no. of alphabet in string
     n=i;
     System.out.println("number of charaters in string = " + n); 
     for (i=0; i<n;i++)
     {
        for (j=i+1; j<n ;j++)
        {
            if (ch[j] == ch[i]) //if an alphabet if repeated...
            {
                c++; // if repeated alphabet found, increment count by 1

                for (k=j; k<n-1;k++) //loop to delete repeated alphabet
                {
                    ch[k] = ch[k+1];//deleting repeated alphabet
                }
             n--; // after deleting repeated alphabet, n is decremented by 1
            }
         }
       System.out.println("alphabet " + ch[i] + " occured " + c + " times");

       c=1; // for counting of next alphabet, now initialized c back to 1
     }  
}}

公共类字母事件{
公共静态void main（字符串[]args）{
字符串s；
s=“ASGFDTRRCJFYDCJHGJ”；
char ch[]=s.toCharArray（）；//已将字符串转换为chararray
int i，j，k，c=1，n；
对于（i=0；我是否需要区分
o
和
o
？我对Java和编程基本不熟悉，因此我不熟悉哈希图和高级API。我将阅读它们，并尝试理解所有答案的含义。谢谢大家！请在下次我编辑答案并尝试以sim卡身份解释时尝试解释答案请尽可能的提供意见…希望现在更好。顺便说一句，谢谢你的建议。
public static void main(String args[]){
    //Convert below lower and upper arrays into one new upperlower map Map<Character, Integer>
    //char[] lower = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
    //char[] upper = new char[] {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
    Map<Character, Integer> countMap = new TreeMap<>();
    Integer count;
    String inputStr = "Hello WORLD";
    char[] arr = inputStr.toCharArray();

    for(Character c : arr){
        count = 0;
        if(c == ' ')
            continue;
        if(countMap.containsKey(c))
            count = countMap.get(c);
        countMap.put(c, count+1);
    }

    Iterator<Entry<Character, Integer>> it = countMap.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<Character, Integer> pair = (Map.Entry<Character, Integer>)it.next();
        System.out.println(pair.getKey() + " = " + pair.getValue());
        it.remove(); // avoids a ConcurrentModificationException

        /*Check pair.getKey() contains on upperlower map if contains assign the new 
          value into map */

    }

    //Finally loop the upperlower Map to display character occurence
}

    String input = "Hello WORLD";

    Map<Character, Integer> map = new TreeMap<>();

    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
            .chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.put(c, 0));

    input.chars()
            .mapToObj(i -> (char) i)
            .forEach(c -> map.computeIfPresent(c, (k, v) -> v + 1));

    System.out.println(map);

    public class AlphabetOccurance {
public static void main(String[] args) {
    String s;
    s = "ASGFDTRRCJFYDCJHGJ";
    char ch[] = s.toCharArray(); // converted string to chararray       
     int i,j,k,c=1,n;
     for (i=0; i<s.length();i++); // loop to find no. of alphabet in string
     n=i;
     System.out.println("number of charaters in string = " + n); 
     for (i=0; i<n;i++)
     {
        for (j=i+1; j<n ;j++)
        {
            if (ch[j] == ch[i]) //if an alphabet if repeated...
            {
                c++; // if repeated alphabet found, increment count by 1

                for (k=j; k<n-1;k++) //loop to delete repeated alphabet
                {
                    ch[k] = ch[k+1];//deleting repeated alphabet
                }
             n--; // after deleting repeated alphabet, n is decremented by 1
            }
         }
       System.out.println("alphabet " + ch[i] + " occured " + c + " times");

       c=1; // for counting of next alphabet, now initialized c back to 1
     }  
}}