Java Hashmap实现来统计每个字符的出现次数

下面的代码用于计算每个字符的出现次数，并应打印计数。 但是用我尝试过的代码，我只得到了1，我不知道我应该做什么更改

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

class Count_CharMap {
public static void main(String[] args) {
    try
    {
        FileInputStream file = new FileInputStream("D:\\trial.txt");
        DataInputStream dis = new DataInputStream(file);
        BufferedReader br = new BufferedReader(new InputStreamReader(dis));
        String Contents="";
        String str="";

        while ((Contents = br.readLine()) != null) {
            str+=Contents;
        }

        char[]char_array =str.toCharArray();
        int count = 0;
        char ch = char_array[count];
        Map<Character,Integer> charCounter=new HashMap<Character,Integer>();
        for(int i=0;i<str.length();i++)
        {
            if(charCounter.containsKey(char_array[i]))
            {
                charCounter.put(ch, charCounter.get(ch)+1);
            } 
            else
            {
                charCounter.put(ch, 1);
            }
       }

       for(Character key:charCounter.keySet())
       {
           System.out.println(key+""+charCounter.get(key));
       }
    } 
    catch(IOException e1){
        System.out.println(e1);
    }
    }
}

导入java.io.BufferedReader；
导入java.io.DataInputStream；
导入java.io.FileInputStream；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.HashMap；
导入java.util.Map；
类计数\u字符映射{
公共静态void main（字符串[]args）{
尝试
{
FileInputStream文件=新的FileInputStream（“D:\\trial.txt”）；
DataInputStream dis=新的DataInputStream（文件）；
BufferedReader br=新的BufferedReader（新的InputStreamReader（dis））；
字符串内容=”；
字符串str=“”；
而（（Contents=br.readLine（））！=null）{
str+=含量；
}
char[]char_array=str.toCharArray（）；
整数计数=0；
char ch=char_数组[计数]；
Map charCounter=new HashMap（）；
对于（inti=0；i，每次执行循环时，您都将char ch设置为相同的字符

应该是：

ch = char_array[i]; 
if(charCounter.containsKey(ch)){
     charCounter.put(ch, charCounter.get(ch)+1);
}
else
{
    charCounter.put(ch, 1);
}

在for循环内部。
导入java.util.HashMap；
import java.util.HashMap;
import java.util.Map;
...
Map<String, Integer> freq = new HashMap<String, Integer>();
...
int count = freq.containsKey(word) ? freq.get(word) : 0;
freq.put(word, count + 1);

导入java.util.Map；
...
Map freq=new HashMap（）；
...
int count=freq.containsKey（word）？freq.get（word）：0；
频率输出（字，计数+1）；
Hai下面的所有代码都是计算每个字符出现的次数，它应该打印计数。可能会对您有所帮助..谢谢您的查看

包com.corejava

import java.util.Map;
import java.util.TreeMap;

public class Test {
    public static void main(String[] args) {

        String str = "ramakoteswararao";

        char[] char_array = str.toCharArray();

        System.out.println("The Given String is : " + str);

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

        for (char i : char_array) {

    charCounter.put(i,charCounter.get(i) == null ? 1 : charCounter.get(i) + 1);

        }

    for (Character key : charCounter.keySet()) {
  System.out.println("occurrence of '" + key + "' is  "+ charCounter.get(key));
        }

    }

}

import java.util.Map；
导入java.util.TreeMap；
公开课考试{
公共静态void main（字符串[]args）{
String str=“ramakoteswararao”；
char[]char_array=str.toCharArray（）；
System.out.println（“给定字符串为：“+str”）；
Map charCounter=new TreeMap（）；
for（字符i:char\u数组）{
charCounter.put（i，charCounter.get（i）=null？1:charCounter.get（i）+1）；
}
for（字符键：charCounter.keySet（））{
System.out.println（“出现“'+key+”是“+charCounter.get（key））；
}
}
}
Java 8流：

Map<String, Long> map = 
    Arrays.stream(string.split("")).
    collect(Collectors.groupingBy(c -> c, Collectors.counting()));

Map=
Arrays.stream（string.split（“”）。
collect（Collectors.groupingBy（c->c，Collectors.counting（））；

番石榴：

Multiset set=HashMultiset.create（Chars.asList（“bbc.tocharray（）））；
资产质量（2，集合计数（'b'））；
在for循环内部

ch=char\u数组[i]；

charCounter.put（charCounter.contains（ch）？charCounter.get（ch）+1:1）；

import java.util.TreeMap；
公共类事件{
公共静态void main（字符串[]args）{
TreeMap mp=newtreemap（）；
String s=“雨走了”；
字符串[]arr=s.split（“”）；
int-length=arr.length；
对于（int i=0；i
String str=new String（“aabbbcddddee”）；
char[]ch=str.toCharArray（）；
HashMap hm=新的HashMap（）；
for（字符ch1:ch）
{
如果（hm.CONTANSKEY（ch1））
{
hm.put（ch1，hm.get（ch1）+1）；
}
其他的
{
hm.put（ch1,1）；
}
}
Set s1=hm.entrySet（）；
迭代器itr=s1.Iterator（）；
while（itr.hasNext（））
{
Map.Entry m1=（Map.Entry）itr.next（）；
系统输出打印项次（m1）；
}
导入java.util.*；
公开课考试{
公共静态void main（字符串[]args）{
String str=“STACKOVERFLOW”；
char[]char_array=str.toCharArray（）；
System.out.println（“给定字符串为：“+str”）；
Map charCounter=new TreeMap（）；
for（字符i:char\u数组）{
charCounter.put（i，charCounter.get（i）=null？1:charCounter.get（i）+1）；
}
for（字符键：charCounter.keySet（））{
System.out.println（“出现“'+key+”是“+charCounter.get（key））；
}
}
}
public void mapractices（）{

Map Map=newhashmap（）；
String dataString=“！@$%^&*（*&^%$$$^&*（*&^%$$^&*（*&^%$$^&*（*&^%$$）^&*（*&^%$$$）^&*（*&^%$$）^&*（*&^%$$$^&*（*&^%$$$$^&*）；
对于（int i=0；i
lambda单衬板

在修复了老派解决方案中的错误后，lambda中有一个替代解决方案可以做同样的事情：

Map<Character,Long> counts =
"an example string to work with".codePoints().boxed().collect(
    groupingBy( t -> (char)(int)t, counting() ) );

Map计数=
“要使用的示例字符串“.codePoints（）.boxed（）.collect”(
分组方式（t->（char）（int）t，counting（））；

获取：
{=5，a=2，e=2，g=1，h=1，i=2，k=1，l=1，m=1，n=2，o=2，p=1，r=2，s=1，t=3，w=2，x=1}


您可以通过以下方式获取特定字符的编号：

counts.get（'t'）

（出于病态的好奇，我还编写了一个lambda解决方案，以了解我的解决方案有多慢，最好是从使用10行解决方案的人那里得到的。）
正确缩进代码，它将帮助您获得帮助。谢谢。愚蠢的I m:-）代码完美地打印了所有字符和出现的地方。我想按字母顺序打印它们。如何做到这一点？使用树形图而不是哈希图，它应该做到这一点。如果没有，你必须使用比较器对其进行排序，谷歌它。嗨，欢迎这样做。当你在代码中发布一个解决方案时，包含一行的简短摘要可能会有所帮助f思考。如果我们需要在上面的示例中获得任何其他键，我们已经使用了goHi，欢迎使用。第一次尝试很好，但您的答案实际上不满足许多要求：（1）它计算单词，而不是字符（2）它不打印单词和结尾的计数-不适用于任意字符串（3）它不是Hashmap，正如所问的那样（4）它实际上并没有修复询问者的代码，但提供了另一种解决方案。请在以后提问之前仔细阅读该问题。请参阅本指南：
import java.util.TreeMap;

public class OccuranceDemo {
    public static void main(String[] args) {
        TreeMap<String , Integer> mp=new TreeMap();
        String s="rain rain go away";
        String[] arr = s.split(" ");
        int length=arr.length;
        for(int i=0;i<length;i++)
       {
         String h = arr[i];
        mp.put(h, mp.get(h)==null?1:mp.get(h)+1);
    }
    System.out.println(mp.get("go"));
  }
}

    String str=new String("aabbbcddddee");
    char[] ch=str.toCharArray();
    HashMap<Character,Integer> hm=new HashMap<Character,Integer>();
    for(char ch1:ch)
    {

        if(hm.containsKey(ch1))
        {
            hm.put(ch1,hm.get(ch1)+1);
        }
        else
        {
            hm.put(ch1,1);
        }
    }

    Set s1=hm.entrySet();
    Iterator itr=s1.iterator();

    while(itr.hasNext())
    {
        Map.Entry m1=(Map.Entry)itr.next();
        System.out.println(m1);
    }

import java.util.*;

public class Test {
    public static void main(String[] args) {

        String str = "STACKOVERFLOW";

        char[] char_array = str.toCharArray();

        System.out.println("The Given String is : " + str);

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

        for (char i : char_array) {

    charCounter.put(i,charCounter.get(i) == null ? 1 : charCounter.get(i) + 1);

        }

    for (Character key : charCounter.keySet()) {
  System.out.println("occurrence of '" + key + "' is  "+ charCounter.get(key));
        }

    }

}

    Map<Character, Integer> map = new HashMap<>();
    String dataString = "!@#$%^&*()__)(*&^%$#@!@#$%^&*(*&^%$#@!@#$%^&*()(*&^%$#@!@#$%^&*()(*&^%$#@!@#$%^&*()(*&^%$#";
    for (int i = 0; i < dataString.length(); i++) {

        char charAt = dataString.charAt(i);

        if (map.containsKey(charAt)) {
            int val = map.get(charAt);
            map.put(charAt, val+1);

        } else {

            map.put(charAt, +1);
        }

    }
    System.out.println("Characters ant the string=" + map);

}

Map<Character,Long> counts =
"an example string to work with".codePoints().boxed().collect(
    groupingBy( t -> (char)(int)t, counting() ) );