題目是這樣的，對字串“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] + "次");
                }
        }
}
 

//統計字串中英文字元的出現次數
//並對次數排序
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;
    }
}
 

其實沒做效率測試，很多能省略的程式碼為了演示也沒刪除，包括最耗時的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毫秒