簡介

Map是鍵值對的集合介面，根據鍵得到值，因此不允許鍵重複，但允許值重複。它的實現類主要包括：HashMap、TreeMap、Hashtable以及LinkedHashMap等。

TreeMap是基於紅黑樹（Red-Black tree）的NavigableMap實現，該對映根據其鍵的自然順序進行排序或者根據建立對映時提供的Comparator進行排序，具體取決於使用的構造方法，預設是按鍵值的升序排序。

HashMap的值是沒有順序的，它是按照Key的HashCode值儲存資料，具有很快的訪問速度，遍歷時取得資料的順序是完全隨機的。最多隻允許一條記錄的鍵為Null，允許多條記錄的值為Null

。不支援執行緒的同步，即任一時刻可以有多個執行緒同時寫HashMap，可能會導致資料的不一致。如果需要同步，可以用Collections的SynchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。

Hashtable與HashMap類似，它繼承自Dictionary類。不同的是：它不允許記錄的鍵或者值為空，它支援執行緒的同步，即任一時刻只有一個執行緒能寫Hashtable，因此也導致了Hashtable在寫入時會比較慢。

LinkedHashMap是HashMap的一個子類，儲存了記錄的插入順序，在用Iterator遍歷LinkedHashMap

時先得到的記錄肯定是先插入的，也可以在構造時帶引數，按照應用次數排序。在遍歷的時候會比HashMap慢，不過有種情況例外，當HashMap容量很大實際資料較少時，遍歷起來可能會比LinkedHashMap慢，因為LinkedHashMap的遍歷速度只和實際資料有關，與容量無關，而HashMap的遍歷速度和它的容量有關。

一般情況下我們用的最多的是HashMap，在Map中插入、刪除和定位元素HashMap是最好的選擇。但如果要按自然順序或自定義順序遍歷鍵，那麼TreeMap會更好。如果需要輸出的順序和輸入相同，那麼用LinkedHashMap可以實現，它還可以按讀取順序來排列。

使用

Key

排序封轉

/**
 * 使用 Map 按 Key 進行排序
 *
 * @param oriMap 排序 Map 集合
 * @param isRise 是否按照升序排序
 */
public static Map<String, String> sortMapByKey(Map<String, String> oriMap, final boolean isRise) {
    if (oriMap == null || oriMap.isEmpty()) {
        return null;
    }

    Map<String, String> sortMap = new TreeMap<>(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            if (isRise) {
                // 升序排序
                return o1.compareTo(o2);
            } else {
                // 降序排序
                return o2.compareTo(o1);
            }
        }
    });
    sortMap.putAll(oriMap);
    return sortMap;
}

Value排序封轉

/**
 * 使用 Map 按 Value 進行排序
 *
 * @param oriMap 排序 Map 集合
 * @param isRise 是否按照升序排序
 */
public static Map<String, String> sortMapByValue(Map<String, String> oriMap, final boolean isRise) {
    if (oriMap == null || oriMap.isEmpty()) {
        return null;
    }

    Map<String, String> sortedMap = new LinkedHashMap<>();
    // 將oriMap.entrySet()轉換成List
    List<Map.Entry<String, String>> entryList = new ArrayList<>(oriMap.entrySet());
    // 通過比較器來實現排序
    Collections.sort(entryList, new Comparator<Map.Entry<String, String>>() {
        @Override
        public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
            if (isRise) {
                // 升序排序
                return o1.getValue().compareTo(o2.getValue());
            } else {
                // 降序排序
                return o2.getValue().compareTo(o1.getValue());
            }
        }
    });

    Iterator<Map.Entry<String, String>> iterator = entryList.iterator();
    Map.Entry<String, String> tmpEntry;
    while (iterator.hasNext()) {
        tmpEntry = iterator.next();
        sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
    }
    return sortedMap;
}

Map集合

Map<String, String> map = new TreeMap<>();
map.put("fck", "fck");
map.put("anb", "anb");
map.put("bwn", "bwn");
map.put("dba", "dba");
map.put("cba", "cba");
map.put("cab", "cab");

Key排序

Map<String, String> keyMap = MapSorting.sortMapByKey(map, true);

for (Map.Entry<String, String> entry : keyMap.entrySet()) {
    Log.e("log", "key sort-->" + entry.getKey() + " : " + entry.getValue());
}

執行結果

key sort-->anb : anb
key sort-->bwn : bwn
key sort-->cab : cab
key sort-->cba : cba
key sort-->dba : dba
key sort-->fck : fck

Value排序

Map<String, String> valueMap = MapSorting.sortMapByValue(map, true);

for (Map.Entry<String, String> entry : valueMap.entrySet()) {
    Log.e("log", "value sort-->" + entry.getKey() + " : " + entry.getValue());
}

執行結果

value sort-->anb : anb
value sort-->bwn : bwn
value sort-->cab : cab
value sort-->cba : cba
value sort-->dba : dba
value sort-->fck : fck