那位同学的意思就是把一个字符串中相同字符的个数取出来，再排序。

1. class xp {
   
2.         public static void main(String[] args) {
   
3.                 charCount("abadcdffbaeba");
   
4.         }
   
5. 
   
6.         public static void sort(int[] arr) {//这个函数是我写的，我在while循环里面将value赋值给一个数组，然后排序
   
7.                 for (int i = 0; i < arr.length; i++) {
   
8.                         for (int j = 0; j < arr.length - i - 1; j++)
   
9.                                 if (arr[j] < arr[j + 1]) {
   
10.                                         int temp = arr[j];
    
11.                                         arr[j] = arr[j + 1];
    
12.                                         arr[j + 1] = temp;
    
13.                                 }
    
14.                 }
    
15.                 for (int i = 0; i < arr.length; i++) {
    
16.                         System.out.println(arr[i]);
    
17.                 }
    
18.         }
    
19.         public static String charCount(String str) {
    
20.                 char[] chs = str.toCharArray();
    
21.                 TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
    
22.                 for (int x = 0; x < chs.length; x++) {
    
23.                         Integer value = tm.get(chs[x]);
    
24.                         if (value == null) {
    
25.                                 tm.put(chs[x], 1);
    
26.                         } else {
    
27.                                 value = value + 1;
    
28.                                 tm.put(chs[x], value);
    
29.                         }
    
30.                 }
    
31.                 Set<Character> keySet = tm.keySet();
    
32.                 Iterator<Character> it = keySet.iterator();
    
33.                 int i = 0;
    
34.                 int[] arr = null;
    
35.                 while (it.hasNext()) {
    
36.                         Character key = it.next();
    
37.                         Integer value = tm.get(key);
    
38.                         //System.out.println(value);这里打印的value是4
    
39.                         arr[i] = value;//张老师不是讲过自动拆箱么？这里为什么还是不能获取到value的值呢？
    
40.                         i++;
    
41.                         System.out.println(key + "::::" + value);
    
42.                 }
    
43.                 /*这是我 看到一哥们的回帖，的确能排序，不过 还不明白这个方法
    
44.                  * List arrayList = new ArrayList(tm.entrySet());
    
45.                  * Collections.sort(arrayList, new Comparator() { public int
    
46.                  * compare(Object o1, Object o2) { Map.Entry obj1 = (Map.Entry) o1;
    
47.                  * Map.Entry obj2 = (Map.Entry) o2; return ((Integer)
    
48.                  * obj2.getValue()).compareTo((Integer) obj1 .getValue()); } });
    
49.                  * System.out.println(arrayList);
    
50.                  */
    
51.                 sort(arr);
    
52.                 return null;
    
53.         }

复制代码

自己顶一个

               int[] arr = null;
                while (it.hasNext()) {
                        Character key = it.next();
                        Integer value = tm.get(key);
                        //System.out.println(value);这里打印的value是4
                        arr[i] = value;//张老师不是讲过自动拆箱么？这里为什么还是不能获取到value的值呢？
                        i++;
                        System.out.println(key + "::::" + value);
                }
哥们你的错误报的是空指针异常
你在上面没给arr分配内存空间 int[] arr = null;
然后给arr[i]赋值，必然会出现空指针异常啊。
改掉以后应该没太多问题了.

顺便讲讲那哥们的回帖
其实就是用匿名内部类的方式定义了arrayList的比较器 ，让arrayList让他所想的顺序来排序
Colections是集合的工具类，里面的sort方法可以传比较器对象进去，
说白了就是你通过实现Comparable接口可以定义任何你想要比较的元素的大小，然后sort（）方法内就是通过你的比较方法就可以将其排序了
我说的不是太清楚，你如果能理解，所有的排序都是通过比较而来这句话应该就比较好理解他的代码了

Collections.sort(arrayList, new Comparator() {})  你说的是这个方法吗？
这里的意思就是对arraylist进行排序，排序的同时传入一个比较器。因Comparator是一个接口，所以需要实现它 重写compare方法。
他这里用了匿名内部类来实现这个方法的。

解决了，谢谢楼上几位！{:soso_e181:}

首先 哥们，你写的是哪个？就一个： public static void sort(int[] arr){} 方法吗？ 但是如果先把这个方法 和你不懂的那个哥们回帖的注释掉时，程序是可以运行的，  但是要把这里的 数组初始化一个长度 ，要不然会提醒：NullPointException ,


修改之后的结果是：      这是按字母排序，

  当运行你看不明白那哥们程序时，结果是 。 按次数排序
其实这个哥们用的方法和原程序中的差不多，都用到集合，将 “字母--出现次数”作为一个键值对存储。刚好分别用到Map 集合遍历的两种方法  keySet  和 entrySet,
   源程序是按keySet, 之后对 出现次数存入数组，存入顺序按照 字母的顺序。   而那哥们的程序是在重新定义排序sort()方法， 此方法中 按  出现次数  的从大到小。

下面是实现方法

public class Test
{
        public static void main(String[] args)
        {
                //key是字符，value是出现的次数
                Map<Character, Integer> map = new TreeMap<Character, Integer>();

                String str = new String("asldhakhshhaskhdhhshdbf");

                char[] chrs = str.toCharArray();

                for (int i = 0; i < chrs.length; i++)
                {
                        if (map.get(chrs[i]) == null)
                        {
                                map.put(chrs[i], new Integer(1));
                        }
                        else
                        {
                                int value = ((Integer) map.get(chrs[i])).intValue();
                                map.put(chrs[i], new Integer(value + 1));
                        }
                }

                Set<Map.Entry<Character, Integer>> set = map.entrySet();

                for (Iterator<Map.Entry<Character, Integer>> iter = set.iterator(); iter.hasNext();)
                {
                        Map.Entry<Character, Integer> entry = iter.next();

                        Character key =  entry.getKey();
                        Integer value =  entry.getValue();

                        System.out.print(key + "=" + value + " ");
                }
               
                System.out.println();
               
                System.out.println("----------------");
               
                //将Entry对象放入到list当中，以便进行排序，因为Collections.sort接收参数是List类型
                List<Map.Entry<Character, Integer>> list = new ArrayList<Map.Entry<Character, Integer>>(set);
               
                //利用Collections自带的排序方法，第二个参数是个内部类，重写方法是自己的比较规则。
                Collections.sort(list, new Comparator<Entry<Character, Integer>>()
                {
                        public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2)
                        {
                                Map.Entry<Character, Integer> m1 = (Map.Entry<Character, Integer>) o1;
                                Map.Entry<Character, Integer> m2 = (Map.Entry<Character, Integer>) o2;
                               
                                Integer i1 =  m1.getValue();
                                Integer i2 =  m2.getValue();
                               
                                return i1 - i2;
                        }
                });
               
                for(Iterator<Map.Entry<Character, Integer>> iter = list.iterator(); iter.hasNext();)
                {
                        System.out.print(iter.next() + " ");
                }
        }
}
运行结果：

a=3 b=1 d=3 f=1 h=8 k=2 l=1 s=4
----------------
b=1 f=1 l=1 k=2 a=3 d=3 s=4 h=8