Map排序的實際應用場景
我們知道，Map不同於List，它是無序的，但我們實際工作中某些業務場景是需要Map按照一定的順序排列組合的，有些需要按鍵排序，有些則需要按值排序。比如說我們現在返回的Map封裝了我們所需要的資料，它的值是無序的，但是我們現在需要將Map按值升序或者降序排列來最終返回我們所要的資料，該怎麼做呢？更復雜的是如果Map是多重巢狀的呢，又該如何實現我們所需要的排序呢？
1.按鍵排序
我們知道，TreeMap預設是按鍵的升序排列的，如果想要Map的值按鍵排序，可以直接用TreeMap,下面我們來看下實際的例子。
@Test
public void TestTreeMapKeyAsc() {
Map<String, String> treeMap = new TreeMap<String, String>();
treeMap.put("2","mad");
treeMap.put("3","kitty");
treeMap.put("1","cherry");
treeMap.put("4","jack");
System.out.println(treeMap);
}
複製程式碼輸出結果
{1=cherry, 2=mad, 3=kitty, 4=jack}
複製程式碼如果我們想讓它降序排列，則需要實現Comparator介面， Comparator是可以對集合物件或者陣列進行排序的比較器介面，最常用的就是給List排序，實現該介面的public compare(T o1,To2)方法即可實現排序，該方法主要是根據第一個引數o1,小於、等於或者大於o2分別返回負整數、0或者正整數。 我們再來看下降序排列的實現
@Test
public void TestTreeMapKeyDesc() {
Map<String, String> treeMap = new TreeMap<String, String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}
});
treeMap.put("2","mad");
treeMap.put("3","kitty");
treeMap.put("1","cherry");
treeMap.put("4","jack");
System.out.println(treeMap);
}
複製程式碼輸出結果
{4=jack, 3=kitty, 2=mad, 1=cherry}
複製程式碼我們前面說的是TreeMap的鍵排序，如果是HashMap呢，我們則需要實現集合排序類Collections的sort方法，但我們看原始碼發現，它只支援List的排序，所以我們這裡需要做一些特殊處理，即把我們的HashMap轉換成一個List,然後再做排序處理。 原始碼：
@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> void sort(List<T> list, Comparator<? super T> c) {
Object[] a = list.toArray();
Arrays.sort(a, (Comparator)c);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++) {
i.next();
i.set((T)a[j]);
}
}
複製程式碼再來看程式碼，實現HashMap按鍵排序（降序）,升序邏輯類似。
@Test
public void TestHashMapKeyDesc() {
Map<String, String> map = new HashMap<String, String>();
map.put("2", "mad");
map.put("3", "cherry");
map.put("1", "kitty");
map.put("4", "jack");
System.out.println(map);
List<Map.Entry<String,String>> list=new ArrayList<Map.Entry<String, String>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
@Override
public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
//降序排列
return o2.getKey().compareTo(o1.getKey());
//升序排序
//return o1.getkey().compareTo(o2.getKey());
}
});
map=new LinkedHashMap<String,String>();
for(Map.Entry<String,String> mapping:list){
System.out.println(mapping.getKey()+":"+mapping.getValue());
map.put(mapping.getKey(),mapping.getValue());
}
System.out.println(map);
}
複製程式碼排序完後我們需要把Map重新定義為LinkedHashMap，即按照插入的順序排序，如果是HashMap的話，又會按照原來的順序排列，是無效的。 輸出結果：
{1=kitty, 2=mad, 3=cherry, 4=jack}
4:jack
3:cherry
2:mad
1:kitty
{4=jack, 3=cherry, 2=mad, 1=kitty}
複製程式碼2.按值排序
按值排序其實和上面HashMap按鍵排序邏輯類似，只有一行程式碼之差，即getKey和getValue的差別，我們這裡還是以TreeMap的值排序為例，給大家看下實際效果。
@Test
public void TestTreeMapValueAsc() {
Map<String, String> treeMap = new TreeMap();
treeMap.put("mad", "2");
treeMap.put("kitty", "3");
treeMap.put("cherry", "1");
treeMap.put("jack", "4");
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(treeMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
@Override
public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
return o1.getValue().compareTo(o2.getValue());
}
});
for(Map.Entry<String,String> mapping:list){
System.out.println(mapping.getKey()+":"+mapping.getValue());
}
}
複製程式碼輸出結果：
cherry:1
mad:2
kitty:3
jack:4
複製程式碼HashMap的實現和TreeMap幾乎一樣，只是它們的型別不同，這裡不再做演示。
3.複雜的值多重排序
我們上面給的例子都是最基本的思路和例子，但實際應用中遠沒有這麼簡單。下面樓主就以實際工作中遇到的一個雙重巢狀的Map值排序做一個演示和講解，首先，由於資料是從DAO資料庫層裡面取出來並且封裝好的，我們實際是在Service層裡面進行處理我們所需要的資料，所以這裡我們就用最原始的方式封裝成類似的Map資料即可。
Map<String, Object> resultMap = new HashMap<String, Object>();
Map<String, String> dataMap = new HashMap<>();
Map<String,String> dataMap1=new HashMap<>();
Map<String,String> dataMap2=new HashMap<>();
Map<String,String> dataMap3=new HashMap<>();
dataMap.put("faultRate", "0.28%");
dataMap.put("faultNum", "1");
dataMap.put("faultTime", "1965");
resultMap.put("出鈔門", dataMap);
dataMap1.put("faultRate", "11.71%");
dataMap1.put("faultNum", "3");
dataMap1.put("faultTime", "80923");
resultMap.put("日誌印表機",dataMap1);
dataMap2.put("faultRate", "12.50%");
dataMap2.put("faultNum", "5");
dataMap2.put("faultTime", "86400");
resultMap.put("出鈔機芯",dataMap2);
dataMap3.put("faultRate", "17.20%");
dataMap3.put("faultNum", "7");
dataMap3.put("faultTime", "86400");
resultMap.put("指紋儀",dataMap3);
複製程式碼我們看下最終生成的map的資料結構：
{出鈔門={faultRate=0.28%, faultNum=1, faultTime=1965},
日誌印表機={faultRate=11.71%, faultNum=3, faultTime=80923},
出鈔機芯={faultRate=12.50%, faultNum=5, faultTime=86400},
指紋儀={faultRate=17.20%, faultNum=7, faultTime=86400}}
複製程式碼我們現在的業務需求就是要把這些資料按照faultRate按從高到低排列（如果是按faultNum或者faultTime，邏輯類似），即
{指紋儀={faultRate=17.20%, faultNum=7, faultTime=86400}
出鈔機芯={faultRate=12.50%, faultNum=5, faultTime=86400}
日誌印表機={faultRate=11.71%, faultNum=3, faultTime=80923}
出鈔門={faultRate=0.28%, faultNum=1, faultTime=1965}}
複製程式碼那麼這又該怎麼處理呢？其實我們仔細觀察這個Map的資料結構，通俗的說，就是要用內層map中一個鍵的值給外層map排序，所謂萬變不離其宗，它最關鍵的還是Map的值排序問題，所以我們還是用值排序的方法進行處理即可，即通過外層map取出內層map，然後再取出它的值進行排序即可。
List<Map.Entry<String,Object>> list=new ArrayList<Map.Entry<String, Object>>(resultMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Object>>() {
@Override
public int compare(Map.Entry<String, Object> o1, Map.Entry<String, Object> o2) {
Map<String, String> o1Map = (Map<String, String>) o1.getValue();
Map<String, String> o2Map = (Map<String, String>) o2.getValue();
Double f1 = Double.valueOf(o1Map.get("faultRate").replace("%", ""));
Double f2 = Double.valueOf(o2Map.get("faultRate").replace("%", ""));
return f2.compareTo(f1);
}
});
複製程式碼這樣就可以實現我們上面的業務需求了，是不是很簡單呢~ 最後把完整的程式碼貼出來，供大家參考：
@Test
public void TestMultipleMapValueSort() {
Map<String, Object> resultMap = new HashMap<String, Object>();
Map<String, String> dataMap = new HashMap<>();
Map<String,String> dataMap1=new HashMap<>();
Map<String,String> dataMap2=new HashMap<>();
Map<String,String> dataMap3=new HashMap<>();
dataMap.put("faultRate", "0.28%");
dataMap.put("faultNum", "1");
dataMap.put("faultTime", "1965");
resultMap.put("出鈔門", dataMap);
dataMap1.put("faultRate", "11.71%");
dataMap1.put("faultNum", "3");
dataMap1.put("faultTime", "80923");
resultMap.put("日誌印表機",dataMap1);
dataMap2.put("faultRate", "12.50%");
dataMap2.put("faultNum", "5");
dataMap2.put("faultTime", "86400");
resultMap.put("出鈔機芯",dataMap2);
dataMap3.put("faultRate", "17.20%");
dataMap3.put("faultNum", "7");
dataMap3.put("faultTime", "86400");
resultMap.put("指紋儀",dataMap3);
System.out.println("排序前:");
for (Map.Entry<String,Object> entry:resultMap.entrySet()){
System.out.println(entry);
};
List<Map.Entry<String,Object>> list=new ArrayList<Map.Entry<String, Object>>(resultMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Object>>() {
@Override
public int compare(Map.Entry<String, Object> o1, Map.Entry<String, Object> o2) {
Map<String, String> o1Map = (Map<String, String>) o1.getValue();
Map<String, String> o2Map = (Map<String, String>) o2.getValue();
Double f1 = Double.valueOf(o1Map.get("faultRate").replace("%", ""));
Double f2 = Double.valueOf(o2Map.get("faultRate").replace("%", ""));
return f2.compareTo(f1);
}
});
Map<String, Object> sortMap = new LinkedHashMap<String, Object>();
for (Map.Entry<String, Object> map : list) {
sortMap.put(map.getKey(), map.getValue());
}
System.out.println("----------------------------------------------");
System.out.println("排序後:");
for (Map.Entry<String,Object> entry:sortMap.entrySet()){
System.out.println(entry);
};
複製程式碼輸出結果：
排序前:
出鈔門={faultRate=0.28%, faultNum=1, faultTime=1965}
日誌印表機={faultRate=11.71%, faultNum=3, faultTime=80923}
出鈔機芯={faultRate=12.50%, faultNum=5, faultTime=86400}
指紋儀={faultRate=17.20%, faultNum=7, faultTime=86400}
----------------------------------------------
排序後:
指紋儀={faultRate=17.20%, faultNum=7, faultTime=86400}
出鈔機芯={faultRate=12.50%, faultNum=5, faultTime=86400}
日誌印表機={faultRate=11.71%, faultNum=3, faultTime=80923}
出鈔門={faultRate=0.28%, faultNum=1, faultTime=1965}
複製程式碼