Java中使用哈希表计算字符发生率

我试图计算字符串中每个字符的出现次数。 所以，如果我输入aaabbbccc，我期望o/p为{a=3，b=3，c=3}，但相反，我继续以{a=1，b=1，c=1}的形式获取它，因为我的哈希表包含方法失败并返回false。代码中有什么错误

我还知道有一个HashMap集合非常类似于hashtable。但是，在学习java的过程中，我想在所有数据结构中尝试相同的代码，只是为了了解方法。带有map的代码与我在这里所做的没有太大的不同，但是这段代码失败了。我无法找出代码中的错误在哪里

我有以下代码：

Hashtable<Character, Integer> stringHash = new Hashtable<Character, Integer>();

Hashtable stringHash=newhashtable（）；

此stringHash是类级变量

for(int i=0; i<s.length(); i++){
        if(stringHash ==null || stringHash.size()==0){
            stringHash.put(s.charAt(i), 1);
        }
        else{
            if(! stringHash.contains(s.charAt(i)) ){
                System.out.println(s.charAt(i));
                stringHash.put(s.charAt(i), 1);
            }
            else{
                int count = stringHash.get(s.charAt(i));
                stringHash.put(s.charAt(i), count++);
            }   
        }
        System.out.println(stringHash + " " + s.charAt(i) + "  "+ stringHash.contains(s.charAt(i)));
}

---

for（int i=0；i此代码适用于我：

String s = "aaabbbccc";

Map<Character, Integer> stringHash = new HashMap<Character, Integer>();
for (char ch : s.toCharArray())
    stringHash.put(ch, stringHash.containsKey(ch) ? (stringHash.get(ch) + 1) : 1);

System.out.println(stringHash);
// output: "{a=3, b=3, c=3}"

String s=“aaabbccc”；
Map stringHash=新建HashMap（）；
for（char ch:s.toCharArray（））
stringHash.put（ch，stringHash.containsKey（ch）？（stringHash.get（ch）+1）；
System.out.println（stringHash）；
//输出：“{a=3，b=3，c=3}”

我使用的是
映射
而不是
哈希表
，但这更常见。
不鼓励调试我的代码问题，但在解决字符串中字符计数的一般问题时，我可以建议一种更简单的方法：

public static int[] countCharacters( String s ){
    int[] count = new int[ 256 ];
    for( int xChar = 0; xChar < s.length(); xChar++ ) count[ s.charAt( xChar ) ]++;
    return count;
}   

public static int[]countCharacters（字符串s）{
int[]计数=新的int[256]；
对于（int-xChar=0；xChar

这假设您有单字节字符。
尝试类似的操作。代码失败的原因是您正在检查哈希表上的contains（），而不是它的键集。希望这能有所帮助

 public static void main(String[] args) {
    // TODO Auto-generated method stub
    String s = "aaaaabbcccc";
    Hashtable<Character, Integer> counter = new Hashtable<Character, Integer>();
    int count = 0;
    for(int i=0;i<s.length();i++){
        if(!counter.keySet().contains(s.charAt(i))){
            counter.put(s.charAt(i), 1);
        } else {
            count = counter.get(s.charAt(i));
            counter.put(s.charAt(i), ++count);
        }
    }

    for(char c:counter.keySet()) {
        System.out.println("Character : "+c+" - Occurences : "+counter.get(c));
    }
}

为什么使用hashMap计算字符发生率？
我将使用大小为255的整数数组，如下所示：

    int[] counter = new int[256];
    String s = "aaabbbcccc";
    for(int i = 0; i < s.length(); i++){
        counter[s.charAt(i)]++;
    }

    for(int i = 0; i < counter.length; i++)
        if(counter[i] > 0)
            System.out.println(((char)i) + " occurs " + counter[i] + " times");

你的代码

if(stringHash ==null || stringHash.size()==0){
    stringHash.put(s.charAt(i), 1);
}

如果hashmap为空，则会抛出。幸运的是，您似乎已正确初始化它。该块本应为空

if(stringHash ==null){
    stringHash = new HashMap()
    stringHash.put(s.charAt(i), 1);
}

同样，这不会修复您的bug。您应该使用
containsKey
而不是
contains
来检查哈希表中的值。您希望实现的内容可以在下面的伪代码中总结

initialize hashmap
for each character c in inputString
  count = 0
  if hashmap has a key for c
     count = get value for c from hashmap
  end if
  put in to hashmap c, count + 1
end for

在Java中，这看起来像：

Map<Character, Integer> charCountMap = new HashMap<>();
for(char c : inputString.toCharArray()){
  int count = 0;
  if(charCountMap.containsKey(c)){
    count = charCountMap.get(c);
  }
  charCountMap.put(c,count+1);
}

Map charCountMap=newhashmap（）；
for（字符c:inputString.toCharArray（））{
整数计数=0；
if（charCountMap.containsKey（c））{
count=charCountMap.get（c）；
}
charCountMap.put（c，count+1）；
}

对于喜欢冒险的人，这里有Java8版本

Map<Character,Long> map = s.chars().mapToObj(i->(char)i)
                                     .collect(Collectors
                                                .groupingBy(e -> e,
                                                   Collectors.counting()));
System.out.println(map);

Map Map=s.chars（）.mapToObj（i->（char）i）
.收藏（收藏家）
.分组方式（e->e，
收集器。计数（）；
系统输出打印项次（map）；

最后，不要使用
哈希表
这是一个遗留类，现在已经没有人使用它了。坚持使用HashMap或其他类型的映射实现。
不要使用哈希表，您可以大大简化代码，类似这样的方法应该可以工作：

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang.StringUtils;

public class Main {

    public static void main(String[] args) {
        Map<Character, Long> countMap = count("aabbbcccc");
        for (Map.Entry<Character, Long> entry : countMap.entrySet()) {
            System.out
                    .println(MessageFormat.format("Char ''{0}'' with count ''{1}''", entry.getKey(), entry.getValue()));
        }
    }

    private static Map<Character, Long> count(String value) {
        Map<Character, Long> countMap = new HashMap<Character, Long>();

        if (StringUtils.isNotBlank(value)) {
            for (int i = 0; i < value.length(); i++) {
                Long count = countMap.get(value.charAt(i));

                count = count == null ? 1 : count + 1;
                countMap.put(value.charAt(i), count);
            }
        }

        return countMap;
    }
}

导入java.text.MessageFormat；
导入java.util.HashMap；
导入java.util.Map；
导入org.apache.commons.lang.StringUtils；
公共班机{
公共静态void main（字符串[]args）{
Map countMap=计数（“aabbbcccc”）；
对于（Map.Entry:countMap.entrySet（））{
系统输出
.println（MessageFormat.format（“计数为“{1}”的字符“{0}”，entry.getKey（），entry.getValue（））；
}
}
私有静态映射计数（字符串值）{
Map countMap=新的HashMap（）；
if（StringUtils.isNotBlank（值））{
对于（int i=0；i
我喜欢您的
if（stringHash==null | | | stringHash.size（）==0）stringHash.put（s.charAt（I），1）；
放在顶部。这将立即成为空引用异常。
if（stringHash==null | | stringHash.size（）==0）
这是无用的。hastable不推荐您使用。请参阅HashMapCount

从何而来？好的，我将尝试使用hashmap，但我的问题是为什么我的包含失败？虽然我是java新手，我正在为集合编写实践程序，但无论我使用table还是map，包含都不应该失败？这确实是一个非常复杂的问题回答并提出一个关于不使用哈希表的好建议。但您也希望在这里包括这样一个事实，即他遇到的问题实际上不是因为使用哈希表，而是因为他错误地使用了.contains（）方法。相反，他应该选择.containsKey（）或.keySet（）.contains（）Upvoting:）

Map<Character,Long> map = s.chars().mapToObj(i->(char)i)
                                     .collect(Collectors
                                                .groupingBy(e -> e,
                                                   Collectors.counting()));
System.out.println(map);

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang.StringUtils;

public class Main {

    public static void main(String[] args) {
        Map<Character, Long> countMap = count("aabbbcccc");
        for (Map.Entry<Character, Long> entry : countMap.entrySet()) {
            System.out
                    .println(MessageFormat.format("Char ''{0}'' with count ''{1}''", entry.getKey(), entry.getValue()));
        }
    }

    private static Map<Character, Long> count(String value) {
        Map<Character, Long> countMap = new HashMap<Character, Long>();

        if (StringUtils.isNotBlank(value)) {
            for (int i = 0; i < value.length(); i++) {
                Long count = countMap.get(value.charAt(i));

                count = count == null ? 1 : count + 1;
                countMap.put(value.charAt(i), count);
            }
        }

        return countMap;
    }
}