package cn.handan;

//
import java.util.TreeMap;

public class Demo12 {
        public static void main(String[] args) {
                String str = "abcdefsdeksdas";
                str = getCharCount(str);
                System.out.println(str);
        }

        public static String getCharCount(String str) {
                char[] chs = str.toCharArray();
                TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
                for (int i = 0; i < chs.length; i++) {
                        Integer value = tm.get(chs[i]);
                        /*遍历的字符第一次出现对应的都为null，通过tm.put(chs[i],1）
                         * 将键对应的值由null改为1（可以理解为此字符出现了一次）
                         * 当次字符第二次出现时，其有对应的值1.所以不为空，通过value++将值改为2，依次类推
                         * if(value==null){ tm.put(chs[i], 1); }else{ value++;
                         * tm.put(chs[i], value);
                         */
                        int count = 0; // 第一次出现的字符（键）对应值为空，通过count++将值改为1.
                        if (value != null) { // 第二次出现时对应的值为1，调用count=value；count++。将值改为2依次类推
                                count = value; //
                        }
                        count++;
                        tm.put(chs[i], count);

                }

                return tm.toString();
        }
}

和老毕说的一致，没错呀。求黑马币

map中建有重复

你的代码和理解没有问题。
利用map的非空判断机制，简单的计数，理解的没有问题，很好，你的这个写法，去除了多余的else，值得推荐。

同样的键，有了不同的值，这样可能有影响吧

我觉得count有点多余，我觉得先遍历char[],再在if-else中调用containsKey()，get(Object key)

我的代码，可能不完善：

1. import java.util.*;
   
2. 
   
3. public class MapDemo {
   
4.         public static void main(String[] args) {
   
5.                 Scanner in = new Scanner(System.in);        //从键盘输入字符串
   
6.                 String srcString = in.nextLine();        //读取源字符串
   
7. 
   
8.                 String result = getCountChar(srcString);
   
9.                 System.out.println(result);
   
10.         }
    
11. 
    
12.         //统计字符的次数
    
13.         public static String getCountChar(String srcStr) {
    
14.                 char[] chs = srcStr.toCharArray();
    
15.                 Map<Character, Integer> map = new HashMap<Character, Integer>();
    
16. 
    
17.                 for (int i=0; i<chs.length; i++) {
    
18.                         if (map.containsKey(chs[i])) {
    
19.                                 map.put(chs[i], map.get(chs[i])+1);        //已存在key-value，value+1再重新插入
    
20.                         } else {
    
21.                                 map.put(chs[i], 1);                //第一次插入key-value
    
22.                         }
    
23.                 }
    
24.                
    
25.                 return map.toString();
    
26.         }
    
27. }

复制代码

感觉好像有点道理

Mr.JUN 发表于 2015-1-6 11:21
我的代码，可能不完善：

HashMap与TreeMap的区别是TreeMap集合输出自带排序（默认自然排序）

1. package com.study;
   
2. 
   
3. import java.util.TreeMap;
   
4. 
   
5. public class Test2 {
   
6.         public static void main(String[] args) {
   
7.                 String str = "aaabbccdeeerrr";
   
8.                 str = getCharCount(str);
   
9.                 System.out.println(str);
   
10.         }
    
11. 
    
12.         public static String getCharCount(String str) {
    
13.                 char[] chs = str.toCharArray();
    
14.                 TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
    
15.                 for (int i = 0; i < chs.length; i++) {
    
16.                         Integer value = tm.get(chs[i]);
    
17. 
    
18.                         value = value == null ? 0 : value;
    
19.                        
    
20.                         tm.put(chs[i], ++value);
    
21. 
    
22.                 }
    
23. 
    
24.                 return tm.toString();
    
25.         }
    
26. }

复制代码

优化版。我只是站在巨人的肩膀上。

没有问题啊

1. package lwj2;
   
2. 
   
3. import java.util.Iterator;
   
4. import java.util.Set;
   
5. import java.util.TreeMap;
   
6. 
   
7. /*
   
8. * 需求：判读"askhdfashdfdvkloiweoibnxcvzfashdfk"字符串中每个字母出现的次数，并排序按照一下格式输出
   
9. * a[3]d[3]f[4]...
   
10. *
    
11. * 分析：
    
12. *         A:需要排序，所以我们采用TreeMap集合存储，并排序
    
13. *         B:怎么存储并计算每个字符出现的次数的？
    
14. *             a:定义TreeMap集合：TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
    
15. *             b:定义count变量，来计算每个字符出现的次数
    
16. *             c:将字符串转化为字符数组，遍历该数组，获取每一个字符，将该字符存进TreeMap集合中
    
17. *                     使用get方法判断返回值：
    
18. *                         如果返回值为null：表示集合里没有这个key，将该字符作为key，1作为value存进集合
    
19. *                         如果返回值不为null：表示集合里已经有这个key，获取该key下的值，并将value++，并将该字符作为key，value++存进集合
    
20. *             d:将该集合转化为指定输出格式的字符串
    
21. *                     创建StringBuilder对象
    
22. *                     遍历该集合
    
23. *                     使用StringBuilder对象对集合数据进行拼接操作
    
24. *                     
    
25. *               a,2
    
26. *               b,4
    
27. *               f,5
    
28. *               t,9
    
29. *            
    
30. *            
    
31. *
    
32. */
    
33. public class TreeMapDemo {
    
34.     public static void main(String[] args) {
    
35.         // 指定需要操作的字符串
    
36.         String s = "askhdfashdfdvkloiweoibnxcvzfashdfk";
    
37. 
    
38.         // 定义TreeMap集合
    
39.         TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
    
40. 
    
41.         // 定义count变量，来计算每个字符出现的次数
    
42.         int count = 0;
    
43. 
    
44.         // 将字符串转化为字符数组
    
45.         char chs[] = s.toCharArray();
    
46. 
    
47.         // 遍历该数组，获取每一个字符，将该字符存进TreeMap集合中
    
48.         for (char ch : chs) {
    
49.             if (tm.get(ch) != null) {
    
50.                 // 表示集合里已经有这个key，获取该key下的值，并将value++,并以ch和value++再次存入集合中
    
51.                 Integer i = tm.get(ch);
    
52. 
    
53.                 // 并将value++
    
54.                 i++;
    
55.                 // 并以ch和value++再次存入集合中
    
56.                 tm.put(ch, i);
    
57.             } else {
    
58.                 // 表示该ch字符之前出现在集合中,将该值存进集合
    
59.                 tm.put(ch, 1);
    
60.             }
    
61.         }
    
62.         // 创建StringBuilder对象
    
63.         StringBuilder sb = new StringBuilder();
    
64.         sb.append("{");
    
65.         // 遍历该集合
    
66.         Set<Character> set = tm.keySet();
    
67.         for (Iterator<Character> it = set.iterator(); it.hasNext();) {
    
68.             Character ch = it.next();
    
69. 
    
70.             Integer i = tm.get(ch);
    
71.             sb.append(ch).append(" = ").append(i).append(",");
    
72.         }
    
73.         sb.append("}");
    
74.         // for (Character ch : set) {
    
75.         // Integer i = tm.get(ch);
    
76.         // if (set.size() == 0) {
    
77.         // sb.append(ch).append("[").append(i).append("]").append(",");
    
78.         // }
    
79.         // }
    
80. 
    
81.         System.out.println(sb.toString());
    
82. 
    
83.     }
    
84. }
    

复制代码