TreeMap 怎么用值排序
下面代码 是用键排序的！想用值排序，不知道哪位大神有好的想法。

public class CiShu {
    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(Founction("aaasdfasdgaa"));
    }
    public static String Founction(String s)
    {
        char[] arr=s.toCharArray();
        TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
        int count=0;
        for(char c:arr)
        {
            Integer value=tm.get(c);
            if(value!=null)
                count=value;
            count++;
            tm.put(c, count);
            count=0;
        }
        Set<Map.Entry<Character,Integer>> entrySet=tm.entrySet();
        Iterator<Map.Entry<Character,Integer>> it=entrySet.iterator();
        StringBuilder sb=new StringBuilder();
        while(it.hasNext())
        {
            Map.Entry<Character, Integer> me=it.next();
            sb.append(me.getKey()+":"+me.getValue());
        }
        return sb.toString();
    }

}

这个我用值排序试过了，不怎么好搞，就collection 接口的  values()方法。这个估计只能用遍历的方法，看值是否相同，然后把对应的键与值打印出来吧。
这个看看其他人有什么好的办法，我也学习学习。

你这是有反常理，即使实现用值排序，但是有什么什么用，那TreeMap判断元素唯一性就会用值来，映射表存在意义是什么？，键值键值，你这样做不就是键就是值，值就是键，毫无意义.当你做这个的时候一定想清楚为什么要做.?思考，思考，学会思考.

何苦似梦离 发表于 2014-2-20 09:28
你这是有反常理，即使实现用值排序，但是有什么什么用，那TreeMap判断元素唯一性就会用值来，映射表存在意 ...

谢谢你的回复，同时你非常感谢你的提醒。只是技术上的探讨。Think out of the box，乔布斯也曾说过：年轻人敢于打破常规才能成功。当然我的意思并不是实际工作中要用值排序。如果你能给出解决方案，那是极好的。道理这玩意.........

何苦似梦离 发表于 2014-2-20 09:28
你这是有反常理，即使实现用值排序，但是有什么什么用，那TreeMap判断元素唯一性就会用值来，映射表存在意 ...

不错啊，想得这么深，再说说啊。让我多学习点，你倒是给了我一个答案啊。当时候我就一直纳闷了，为什么有getkey方法而没有getvalues方法进行操作

public class TreeMapTest {
        public static void main(String[] args)
        {
                TreeMap<String, Integer> tr = new TreeMap();
               
                tr.put("a", 3);
                tr.put("b", 5);
                tr.put("c", 4);
                tr.put("d", 2);
                Set<Map.Entry<String, Integer>> setMap = tr.entrySet();
               
                //打印按键排序的结界
                for(Map.Entry temp : setMap)
                {
                        System.out.println(temp.getKey() + ":" + temp.getValue());
                }
                System.out.println("=================");
                int size = tr.size();
               
                MapSort<String, Integer>[] mapSortArr = new MapSort[size];
                int index = 0;
               
                for(Map.Entry<String, Integer> temp : setMap)
                {
                        mapSortArr[index] =  new MapSort(temp.getKey(), temp.getValue());
                        index++;
                }
                //对值进行插入排序
                for(index = 1; index < size; index++)
                {
                        int i = index - 1;
                        Integer keyVal = mapSortArr[index].val;

                        String  keyString = mapSortArr[index].key;
                        
                        while((i >= 0) && ((mapSortArr.val).compareTo(keyVal) == 1))
                        {
                                mapSortArr[i + 1].key = mapSortArr.key;
                                mapSortArr[i + 1].val = mapSortArr.val;
                                i--;                                
                        }
                        
                        mapSortArr[i + 1].key = keyString;
                        mapSortArr[i + 1].val = keyVal;
                }
                //打印按值排序后的结果。
                for(MapSort mTemp : mapSortArr)
                {
                        System.out.println(mTemp.key + ":" + mTemp.val);
                }
        }
        
}
class MapSort<K, V>
{
        public K key;
        public V val;
        MapSort(K key, V val)
        {
                this.key = key;
                this.val = val;
        }
}

稍微实现了下，我觉得值得考虑，就试着写了下，看看OK不。  

可以先静态定义一个以键排序的TreeMap tm，并在静态代码块中加入元素
然后再定义一个TreeMap tm1 ，指定构造器，以值排序。
再将tm映射关系复制tm1中

1. import java.util.Comparator;
   
2. import java.util.Iterator;
   
3. import java.util.Set;
   
4. import java.util.TreeMap;
   
5. public class ValueSort {
   
6.               //静态定义一个TreeMap,以键的自然顺序排序
   
7.         public static TreeMap<String,Integer> tm =
   
8.                 new TreeMap<String,Integer>();
   
9.         static{
   
10.             tm.put("lisi",21);
    
11.                 tm.put("zhangshan",27);
    
12.                 tm.put("wangwu",15);
    
13.                 tm.put("zhaoliu",23);
    
14.         }
    
15.         public static void main(String[] args) {
    
16.                         //另外定义一个TreeMap,指定比较器，以值排序
    
17.                 TreeMap<String,Integer> tm1 =
    
18.                         new TreeMap<String,Integer>(new StuNameComparator());
    
19.                    //将tm的映射关系全部复制放入tm1中       
    
20.                 tm1.putAll(tm);                     
    
21.                 Set<String> keySet = tm1.keySet();
    
22.                 Iterator<String> it = keySet.iterator();
    
23.                 while(it.hasNext()){
    
24.                         String name = it.next();
    
25.                         Integer age = tm1.get(name);
    
26.                         System.out.println(name+":"+age);
    
27.                 }                       
    
28.         }       
    
29.                 //获取tm中的value值
    
30.         public static Integer getValue(String name){  
    
31.                 return tm.get(name);
    
32.         }
    
33. }
    
34. class StuNameComparator implements Comparator<String>{
    
35.                 // 定义以值排序的比较器
    
36.         @Override
    
37.         public int compare(String o1, String o2) {
    
38.                 Integer x = ValueSort.getValue(o1);
    
39.                 Integer y = ValueSort.getValue(o2);
    
40.                 return x.compareTo(y);
    
41.         }
    
42. }

复制代码