呵呵，标题就调侃下，没别的意思
说正题有位同仁Destiny发了一个map统计排序的帖子，我视频着实没看到那里，所以也不知道怎么去回复，想了想map操作貌似不是很快，所以我用了稍微快速点的办法，呵呵
题目是这样的，对字符串“sdfgzxcvasdfxcvdf”每个字符出现次数并对其排序

这个是对于只有小写字母的，采用的字符的ascii表值的相对映射关系，排序先放后边，一会说，先看统计

1.         public static void main(String[] args)
   
2.         {
   
3.                 //统计字符串中英文字符的出现次数
   
4.                 String string = "sdfgzxcvasdfxcvdf";
   
5.                 char[] c = string.toCharArray();
   
6.                 //用来保存26个英文字母出现的次数
   
7.                 //该数组0为a 25为z
   
8.                 //使用时以字符的ascii码值减去97
   
9.                 //因为a字符的ascii值为97
   
10.                 //这里的ascii编码表其实就是张map
    
11.                 int[] temp = new int[26];
    
12.                 for(char ch : c)
    
13.                 {
    
14.                         temp[ch-97] ++;
    
15.                 }
    
16.                
    
17.                 for(char d = 'a'; d < 'z' + 1; d++)
    
18.                 {
    
19.                         System.out.println("" + d + "出现了" + temp[d-97] + "次");
    
20.                 }
    
21.         }

复制代码

话说万一要是有大些字母或者符号肿么办？骚年别着急，咱这么办

1. 
   
2. //统计字符串中英文字符的出现次数
   
3. //并对次数排序
   
4. public class Demo
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                
   
9.                 String string = "sdfgzxcvasdfxcvdf";
   
10.                 char[] c = string.toCharArray();
    
11.                 // 用来存放ascii字符的次数
    
12.                 int[] ascii = new int[255];
    
13.                 for(char ch : c)
    
14.                 {
    
15.                         ascii[ch]++;
    
16.                 }
    
17.                
    
18.                 for(char d = 'a'; d < 'z' + 1; d++)
    
19.                 {
    
20.                         System.out.println("" + d + "出现了" + ascii[d] + "次");
    
21.                 }
    
22.         }
    
23. }
    

复制代码

额，要是整张的ascii表都不够用，你非得中文啥的，也行，我靠，我就定义成字符类型最大长度，这回怕了吧，哼哼，不过那个先不考虑他，没必要，方法都是一样的。

下边这个是完整的，我希望的话呢，做东西不要照抄老师的，要灵学活用，我们自己通过其他方式也实现下，也能开阔思维，很多看起来很爽的api也是基础知识堆出来的不是么，呵呵，具体的设计思路，注释里都有，希望能给大家打开一扇新的窗户。

1. 
   
2. 
   
3. //统计字符串中英文字符的出现次数
   
4. //并对次数排序
   
5. public class Demo
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 long taken = System.currentTimeMillis();
   
10.                 String string = "sdf/gz.xcv.a.sdfx/cvdf.";
    
11.                 char[] c = string.toCharArray();
    
12.                 // 用来存放数据的数组，索引为字符的ascii编码值
    
13.                 int[] data = new int[256];
    
14.                
    
15.                 //对字符的出现次数进行统计，以int的32位为基础
    
16.                 //最高8位用来存储字符，即表示是哪个字符，一个
    
17.                 //字节的长度也正好跟ascii表对应，最低8位为该
    
18.                 //字符的出现次数，当然超过字节长度的话就不好用
    
19.                 //这里暂时不讨论，因为我们可以以24位长度来计算
    
20.                 //次数
    
21.                 for(char ch : c)
    
22.                 {
    
23.                         //最低8位表示出现次数，但跟高8位没关系，所以
    
24.                         //这里我们使用自增来增加出现次数，而字符怎么
    
25.                         //放到高8位呢，我们采用|运算符，即相加
    
26.                         data[ch] = ++data[ch] | (((int)ch) << 24);
    
27.                 }
    
28.                
    
29.                 for(int i = 0; i < 256; i++)
    
30.                 {
    
31.                         // 把出现过的字符全部挪到数组最前端用以排除排序时无效数据
    
32.                         if(data[i] != 0)
    
33.                         {
    
34.                                 //将数据转换成字符的话，我们需要使该数&一个0xffffff00
    
35.                                 //即最低8位数据清0，然后我们右移24位，这样就得到了这个
    
36.                                 //字符的值，呵呵，那么得到数据怎么得到呢，我们采用数据
    
37.                                 //&上一个0xff，这样就是说抛弃高24位的所有数据归0，我们
    
38.                                 //也就得到了这个字符的出现次数
    
39.                                 System.out.println("" + ((char)((data[i] & 0xffffff00) >> 24)) + "出现了" + (data[i] & 0xff) + "次");
    
40.                                 for(int j = 0; j < data.length; j++)
    
41.                                 {
    
42.                                         if(data[j] == 0)
    
43.                                         {
    
44.                                                 data[j] = data[i];
    
45.                                                 data[i] = 0;
    
46.                                         }
    
47.                                 }
    
48.                         }
    
49.                 }
    
50.                 System.out.println("===========================>");
    
51.                 // 重新打印一遍数组，并观察是否数据都在数组的最前端
    
52.                 // 并在发现无效数据时跳出循环
    
53.                 for(int i = 0; i < data.length; i++)
    
54.                 {
    
55.                         if(data[i] == 0)
    
56.                         {
    
57.                                 int[] temp = new int[i];
    
58.                                 System.arraycopy(data, 0, temp, 0, i);
    
59.                                 data = temp;
    
60.                                 break;
    
61.                         }
    
62.                         System.out.println("" + ((char)((data[i] & 0xffffff00) >> 24)) + "出现了" + (data[i] & 0xff) + "次    循环执行到第" + i + "次");
    
63.                 }
    
64.                
    
65.                 //进行排序
    
66.                 sort(data);
    
67.                
    
68.                 //打印排序结果
    
69.                 System.out.println("===========================>");
    
70.                 for (int i : data)
    
71.                 {
    
72.                         System.out.println("" + ((char)((i & 0xffffff00) >> 24)) + "出现了" + (i & 0xff) + "次");
    
73.                 }
    
74.                
    
75.                
    
76.                 taken = System.currentTimeMillis() - taken;
    
77.                 System.out.println("===========================>");
    
78.                 System.out.println("耗时" + taken + "毫秒");
    
79.         }
    
80.        
    
81.         /**
    
82.          * 冒泡排序，这个真就不说了，大家都懂
    
83.          */
    
84.         public static void sort(int[] data)
    
85.         {
    
86.         for(int i = 0; i < data.length; i++)
    
87.         {
    
88.             for(int j = data.length - 1; j > i; j--)
    
89.             {
    
90.                 if((data[j] << 24) < (data[j-1] << 24))
    
91.                 {
    
92.                     swap(data, j, j - 1);
    
93.                 }
    
94.             }
    
95.         }
    
96.     }
    
97.        
    
98.         public static void swap(int[] data, int i, int j)
    
99.         {
    
100.         int temp = data[i];
     
101.         data[i] = data[j];
     
102.         data[j] = temp;
     
103.     }
     
104. }
     

复制代码

最后说点啥呢，呵呵，就是毕老师的map简直弱爆了，在调侃下，木哈哈，最重要的是，写东西要根据需求来写最简单的代码，这也是为什么我分了3段来演示，如果只有小写字母的第一个是最方便的

1. 其实没做效率测试，很多能省略的代码为了演示也没删除，包括最耗时的syso方法。
   
2. .出现了4次
   
3. /出现了2次
   
4. a出现了1次
   
5. c出现了2次
   
6. d出现了3次
   
7. f出现了3次
   
8. g出现了1次
   
9. s出现了2次
   
10. v出现了2次
    
11. x出现了2次
    
12. z出现了1次
    
13. ===========================>
    
14. .出现了4次    循环执行到第0次
    
15. /出现了2次    循环执行到第1次
    
16. a出现了1次    循环执行到第2次
    
17. c出现了2次    循环执行到第3次
    
18. d出现了3次    循环执行到第4次
    
19. f出现了3次    循环执行到第5次
    
20. g出现了1次    循环执行到第6次
    
21. s出现了2次    循环执行到第7次
    
22. v出现了2次    循环执行到第8次
    
23. x出现了2次    循环执行到第9次
    
24. z出现了1次    循环执行到第10次
    
25. ===========================>
    
26. a出现了1次
    
27. g出现了1次
    
28. z出现了1次
    
29. /出现了2次
    
30. c出现了2次
    
31. s出现了2次
    
32. v出现了2次
    
33. x出现了2次
    
34. d出现了3次
    
35. f出现了3次
    
36. .出现了4次
    
37. ===========================>
    
38. 耗时0毫秒

复制代码

...{:soso_e141:}

H07000223 发表于 2012-3-25 11:02
...

楼上的注意公众形象