/**
*
*/
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;
}
*
*/
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的地址不相等即可。
- public class Test {
- public static void main(String[] args) {
- //不指定排序器
- TreeMap<String, String> treeMap1 = new TreeMap<String, String>();
- treeMap1.put("2", "1");
- treeMap1.put("b", "1");
- treeMap1.put("1", "1");
- treeMap1.put("a", "1");
- System.out.println("treeMap1="+treeMap1);
- //指定排序器
- TreeMap<String, String> treeMap2 = new TreeMap<String, String>(new Comparator<String>(){
- /*
- * int compare(Object o1, Object o2) 返回一个基本类型的整型,
- * 返回负数表示:o1 小于o2,
- * 返回0 表示:o1和o2相等,
- * 返回正数表示:o1大于o2。
- */
- public int compare(String o1, String o2) {
- //指定排序器按照降序排列
- return o2.compareTo(o1);
- }
- });
- treeMap2.put("2", "1");
- treeMap2.put("b", "1");
- treeMap2.put("1", "1");
- treeMap2.put("a", "1");
- System.out.println("treeMap2="+treeMap2);
- }
- }
执行输出结果:
- treeMap1={1=1, 2=1, a=1, b=1}
- treeMap2={b=1, a=1, 2=1, 1=1}