map对值排序

/**
 * 
 */
package com.fritt.planmanage.util;


import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;


import edu.emory.mathcs.backport.java.util.Collections;


/**
 * @author lf
 * 
 */
public class SortMap {


public  static Map<String, Integer> sortMap(Map<String, Integer> oldMap) {
ArrayList<Map.Entry<String, Integer>> list = 
new ArrayList<Map.Entry<String, Integer>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {


@Override
public int compare(Entry<java.lang.String, Integer> arg0,
Entry<java.lang.String, Integer> arg1) {
return arg1.getValue() - arg0.getValue();           //对map值进行降序排序
}
});
Map<String, Integer> newMap = new LinkedHashMap<String, Integer>();
for (int i = 0; i < list.size(); i++) {
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

public  static Map<String, Double> sortMap_Double(Map<String, Double> oldMap) {
ArrayList<Map.Entry<String, Double>> list = 
new ArrayList<Map.Entry<String, Double>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Double>>() {


@Override
public int compare(Entry<java.lang.String, Double> arg0,
Entry<java.lang.String, Double> arg1) {

return arg1.getValue().compareTo(arg0.getValue());
}
});
Map<String, Double> newMap = new LinkedHashMap<String, Double>();
for (int i = 0; i <list.size(); i++) {
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

public  static Map<String, String> sortMap_String(Map<String, String> oldMap) {
ArrayList<Map.Entry<String, String>> list = 
new ArrayList<Map.Entry<String, String>>(oldMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {


@Override
public int compare(Entry<String, String> arg0,Entry<String,String> arg1) {
return arg0.getValue().compareTo(arg1.getValue());      //升序排序
}
});
Map<String, String> newMap = new LinkedHashMap<String, String>();
for (int i = list.size()-1; i >=0; i--) {                        //从后向前导入，相当于降序
newMap.put(list.get(i).getKey(), list.get(i).getValue());
}
return newMap;
}

}

HashMap:输入的<key,value>对是乱序插入，比较快，key不允许重复

TreeMap:有序，对输入的<key,value>进行排序，默认将按照key值进行升序排序，key不允许重复，若重复，后面的覆盖前面的

LinkedHashMap:它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。

IdentityHashMap:key允许重复，只要两个key的地址不相等即可。

1. public class Test {  
2.       
3.     public static void main(String[] args) {  
4.           
5.         //不指定排序器  
6.         TreeMap<String, String> treeMap1 = new TreeMap<String, String>();  
7.         treeMap1.put("2", "1");  
8.         treeMap1.put("b", "1");  
9.         treeMap1.put("1", "1");  
10.         treeMap1.put("a", "1");  
11.         System.out.println("treeMap1="+treeMap1);  
12.   
13.         //指定排序器  
14.         TreeMap<String, String> treeMap2 = new TreeMap<String, String>(new Comparator<String>(){  
15.   
16.             /* 
17.              * int compare(Object o1, Object o2) 返回一个基本类型的整型， 
18.              * 返回负数表示：o1 小于o2， 
19.              * 返回0 表示：o1和o2相等， 
20.              * 返回正数表示：o1大于o2。 
21.              */  
22.             public int compare(String o1, String o2) {  
23.               
24.                 //指定排序器按照降序排列  
25.                 return o2.compareTo(o1);  
26.             }     
27.         });  
28.         treeMap2.put("2", "1");  
29.         treeMap2.put("b", "1");  
30.         treeMap2.put("1", "1");  
31.         treeMap2.put("a", "1");  
32.         System.out.println("treeMap2="+treeMap2);  
33.     }  
34. }  

 

执行输出结果：

Java代码  

1. treeMap1={1=1, 2=1, a=1, b=1}  
2. treeMap2={b=1, a=1, 2=1, 1=1}