统计字符串中字符出现次数以及排序

题目是这样的，对字符串“sdfgzxcvasdfxcvdf”每个字符出现次数并对其排序

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

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

//统计字符串中英文字符的出现次数
//并对次数排序
public class Demo
{
        public static void main(String[] args)
        {
                
                String string = "sdfgzxcvasdfxcvdf";
                char[] c = string.toCharArray();
                // 用来存放ascii字符的次数
                int[] ascii = new int[255];
                for(char ch : c)
                {
                        ascii[ch]++;
                }
                
                for(char d = 'a'; d < 'z' + 1; d++)
                {
                        System.out.println("" + d + "出现了" + ascii[d] + "次");
                }
        }
}

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

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

//统计字符串中英文字符的出现次数
//并对次数排序
public class Demo
{
        public static void main(String[] args)
        {
                long taken = System.currentTimeMillis();
                String string = "sdf/gz.xcv.a.sdfx/cvdf.";
                char[] c = string.toCharArray();
                // 用来存放数据的数组，索引为字符的ascii编码值
                int[] data = new int[256];
                
                //对字符的出现次数进行统计，以int的32位为基础
                //最高8位用来存储字符，即表示是哪个字符，一个
                //字节的长度也正好跟ascii表对应，最低8位为该
                //字符的出现次数，当然超过字节长度的话就不好用
                //这里暂时不讨论，因为我们可以以24位长度来计算
                //次数
                for(char ch : c)
                {
                        //最低8位表示出现次数，但跟高8位没关系，所以
                        //这里我们使用自增来增加出现次数，而字符怎么
                        //放到高8位呢，我们采用|运算符，即相加
                        data[ch] = ++data[ch] | (((int)ch) << 24);
                }
                
                for(int i = 0; i < 256; i++)
                {
                        // 把出现过的字符全部挪到数组最前端用以排除排序时无效数据
                        if(data[i] != 0)
                        {
                                //将数据转换成字符的话，我们需要使该数&一个0xffffff00
                                //即最低8位数据清0，然后我们右移24位，这样就得到了这个
                                //字符的值，呵呵，那么得到数据怎么得到呢，我们采用数据
                                //&上一个0xff，这样就是说抛弃高24位的所有数据归0，我们
                                //也就得到了这个字符的出现次数
                                System.out.println("" + ((char)((data[i] & 0xffffff00) >> 24)) + "出现了" + (data[i] & 0xff) + "次");
                                for(int j = 0; j < data.length; j++)
                                {
                                        if(data[j] == 0)
                                        {
                                                data[j] = data[i];
                                                data[i] = 0;
                                        }
                                }
                        }
                }
                System.out.println("===========================>");
                // 重新打印一遍数组，并观察是否数据都在数组的最前端
                // 并在发现无效数据时跳出循环
                for(int i = 0; i < data.length; i++)
                {
                        if(data[i] == 0)
                        {
                                int[] temp = new int[i];
                                System.arraycopy(data, 0, temp, 0, i);
                                data = temp;
                                break;
                        }
                        System.out.println("" + ((char)((data[i] & 0xffffff00) >> 24)) + "出现了" + (data[i] & 0xff) + "次    循环执行到第" + i + "次");
                }
                
                //进行排序
                sort(data);
                
                //打印排序结果
                System.out.println("===========================>");
                for (int i : data)
                {
                        System.out.println("" + ((char)((i & 0xffffff00) >> 24)) + "出现了" + (i & 0xff) + "次");
                }
                
                
                taken = System.currentTimeMillis() - taken;
                System.out.println("===========================>");
                System.out.println("耗时" + taken + "毫秒");
        }
        
        /**
         * 冒泡排序，这个真就不说了，大家都懂
         */
        public static void sort(int[] data) 
        {
        for(int i = 0; i < data.length; i++)
        {
            for(int j = data.length - 1; j > i; j--)
            {
                if((data[j] << 24) < (data[j-1] << 24))
                {
                    swap(data, j, j - 1);
                }
            }
        }
    }
        
        public static void swap(int[] data, int i, int j) 
        {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

写东西要根据需求来写最简单的代码，这也是为什么我分了3段来演示，如果只有小写字母的第一个是最方便的

其实没做效率测试，很多能省略的代码为了演示也没删除，包括最耗时的syso方法。
.出现了4次
/出现了2次
a出现了1次
c出现了2次
d出现了3次
f出现了3次
g出现了1次
s出现了2次
v出现了2次
x出现了2次
z出现了1次
===========================>
.出现了4次    循环执行到第0次
/出现了2次    循环执行到第1次
a出现了1次    循环执行到第2次
c出现了2次    循环执行到第3次
d出现了3次    循环执行到第4次
f出现了3次    循环执行到第5次
g出现了1次    循环执行到第6次
s出现了2次    循环执行到第7次
v出现了2次    循环执行到第8次
x出现了2次    循环执行到第9次
z出现了1次    循环执行到第10次
===========================>
a出现了1次
g出现了1次
z出现了1次
/出现了2次
c出现了2次
s出现了2次
v出现了2次
x出现了2次
d出现了3次
f出现了3次
.出现了4次
===========================>
耗时0毫秒