对HashMap的键值进行排序

首先来看看Map集合获取元素的三种常见方法keySet()、values()、entrySet()

1. values()：返回map集合的所有value的Collection集合（于集合中无序存放）

 1 import java.util.*;
 2 
 3 public class Main{
 4     public static void main(String[] args){
 5         Map<String, String> map = new HashMap<String, String>();    //构建键值对为<String, String>的Map集合
 6         map.put("a", "aaa");
 7         map.put("b", "bbb");
 8         map.put("c", "ccc");
 9     
10         Collection<String> collection = map.values();    //获取map集合的所有value的Collection集合（于集合中无序存放）
11         System.out.println(collection);
12     }
13 }
14 
15 /**
16  * 运行结果
17  * [bbb, ccc, aaa]
18  */

2. keySet()：返回map集合的所有键的Set集合（于Set集合中无序存放）

通过迭代取出所有key，再利用get()方法获取value, for(类型 元素： 集合) 的本质是获取集合的迭代器进行迭代

 1 import java.util.*;
 2  
 3 public class Main{
 4     public static void main(String[] args){
 5         Map<String, String> map = new HashMap<String, String>();    //构建键值对为<String, String>的Map集合
 6         map.put("a", "aaa");
 7         map.put("b", "bbb");
 8         map.put("c", "ccc");
 9         
10         Set<String> keySet = map.keySet();    //获取map集合的所有键的Set集合（于Set集合中无序存放）
11         Iterator<String> iter = keySet.iterator();    //获取keySet集合的迭代器
12         while(iter.hasNext()){
13             String key = iter.next();
14             String value = map.get(key);
15             System.out.println("key:" + key + "-->value:" + value);
16         }
17         /*
18         for(String key: keySet){
19             String value = map.get(key);
20             System.out.println("key:" + key + "-->value:" + value);
21         }
22         */
23     }
24 }
25 
26 /**
27  * 运行结果
28  * key:b-->value:bbb
29  * key:c-->value:ccc
30  * key:a-->value:aaa
31  */

3. entrySet()：返回map集合的所有"映射"的Set集合,这里规范每个"映射"的类型为Map.Entry<K, V>（于Set集合中无序存放）

通过迭代取出所有的“映射”，再利用getKey()、getValue()方法获取相应键、值

 1 import java.util.*;
 2 
 3 public class Main{
 4     public static void main(String[] args){
 5         Map<String, String> map = new HashMap<String, String>();    //构建键值对为<String, String>的Map集合
 6         map.put("a", "aaa");
 7         map.put("b", "bbb");
 8         map.put("c", "ccc");
 9     
10         Set<Map.Entry<String, String>> entrySet = map.entrySet();    //获取map集合的所有"映射"的Set集合,这里规范每个映射的类型为Map.Entry<K, V>（于Set集合中无序存放）
11         Iterator<Map.Entry<String, String>> iter = entrySet.iterator();    //获取entrySet集合的迭代器,Map.Entry<K, V>为迭代元素的类型
12         while(iter.hasNext()){
13             Map.Entry<String, String> item = iter.next();
14             String key = item.getKey();
15             String value = item.getValue();
16             System.out.println("key:" + key + "-->value:" + value);
17         }
18         /*
19         for(Map.Entry<String, String> item: entrySet){
20             String key = item.getKey();
21             String value = item.getValue();
22             System.out.println("key:" + key + "-->value:" + value);
23         }
24         */
25     }
26 }
27 
28 /**
29  * 运行结果
30  * key:b-->value:bbb
31  * key:c-->value:ccc
32  * key:a-->value:aaa
33  */

 

---

 

有以上方法作为基础，那么我们很容易想到对HashMap进行排序的两种方法

1. 通过keySet()获取Map集合的所有键的Set集合，由List集合获取其中所有元素，通过比较器对元素为键的List集合进行排序

2. 通过entrySet()获取Map集合所有映射的Set集合，由List集合获取其中所有元素，通过比较器对元素为"映射"List集合进行排序

通过对比较器compare方法的Override，两者还可以实现利用value进行排序。有关java中Comparable和Comparator比较的详解

 1 import java.util.*;
 2 
 3 public class DescKeyComparator implements Comparator<String>{
 4     public static void main(String[] args){
 5         Map<String, String> map = new HashMap<String, String>();    //构建键值对为<String, String>的Map集合
 6         map.put("a", "aaa");
 7         map.put("b", "bbb");
 8         map.put("c", "ccc");
 9     
10         Set<String> entrySet = map.keySet();    //获取map集合的所有键的Set集合（于Set集合中无序存放）
11         List<String> list = new ArrayList<String>(entrySet);    //新建List集合获取Set集合的所有元素（键对象）（顺序与Set集合一样）
12         /** 
13          * 接下来的排序是list的专长了
14          * 通过“比较器(DescKeyComparator)”，对list进行排序
15          */
16         Collections.sort(list, new DescKeyComparator());
17         /*
18         Collections.sort(list);    //String实现了Comparable，默认升序排列
19         */
20         Iterator<String> iter = list.iterator();    //获取List集合的迭代器,String为迭代元素的类型
21         while(iter.hasNext()){
22             String key = iter.next();
23             String value = map.get(key);
24             System.out.println("key:" + key + "-->value:" + value);
25         }
26         /*
27         for(Map.Entry<String, String> item: list){
28             String key = iter.next();
29             String value = map.get(key);
30             System.out.println("key:" + key + "-->value:" + value);
31         }
32         */
33     }
34     
35     @Override
36     public int compare(String key1, String key2){
37         return key2.compareTo(key1);    //降序排序; String作为api提供的类，实现了Comparable的compareTo方法被设计成小于、等于、大于分别返回负数、零、正数
38     }
39 }
40 
41 /**
42  * 运行结果
43  * key:c-->value:ccc
44  * key:b-->value:bbb
45  * key:a-->value:aaa
46  */

 

 1 import java.util.*;
 2 
 3 public class AscKeyComparator implements Comparator<Map.Entry<String, String>>{
 4     public static void main(String[] args){
 5         Map<String, String> map = new HashMap<String, String>();    //构建键值对为<String, String>的Map集合
 6         map.put("a", "aaa");
 7         map.put("b", "bbb");
 8         map.put("c", "ccc");
 9     
10         Set<Map.Entry<String, String>> entrySet = map.entrySet();    //获取map集合的所有"映射"的Set集合,这里规范每个映射的类型为Map.Entry<K, V>（于Set集合中无序存放）
11         List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(entrySet);    //新建List集合获取Set集合的所有元素（"映射"对象）（顺序与Set集合一样）
12         /** 
13          * 接下来的排序是list的专长了
14          * 通过“比较器(AscKeyComparator)”，对list进行排序
15          */
16         Collections.sort(list, new AscKeyComparator());
17         
18         Iterator<Map.Entry<String, String>> iter = list.iterator();    //获取List集合的迭代器,Map.Entry<K, V>为迭代元素的类型
19         while(iter.hasNext()){
20             Map.Entry<String, String> item = iter.next();
21             String key = item.getKey();
22             String value = item.getValue();
23             System.out.println("key:" + key + "-->value:" + value);
24         }
25         /*
26         for(Map.Entry<String, String> item: list){
27             String key = item.getKey();
28             String value = item.getValue();
29             System.out.println("key:" + key + "-->value:" + value);
30         }
31         */
32     }
33     
34     @Override
35     public int compare(Map.Entry<String, String> item1, Map.Entry<String, String> item2){
36         return item1.getKey().compareTo(item2.getKey());    //升序排序
37     }
38 }
39 
40 /**
41  * 运行结果
42  * key:a-->value:aaa
43  * key:b-->value:bbb
44  * key:c-->value:ccc
45  */

第五个
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
public class SortMapByValues {
 
    public static void main(String[] args) {
 
        Map<String,Integer> aMap = new HashMap<String,Integer>();
 
        // adding keys and values
        aMap.put("Five", 5);
        aMap.put("Seven", 7);
        aMap.put("Eight", 8);
        aMap.put("One",1);
        aMap.put("Two",2);
        aMap.put("Three", 3);
 
        sortMapByValues(aMap);
 
    }
 
    private static void sortMapByValues(Map<String, Integer> aMap) {
 
        Set<Entry<String,Integer>> mapEntries = aMap.entrySet();
 
        System.out.println("Values and Keys before sorting ");
        for(Entry<String,Integer> entry : mapEntries) {
            System.out.println(entry.getValue() + " - "+ entry.getKey());
        }
 
        // used linked list to sort, because insertion of elements in linked list is faster than an array list. 
        List<Entry<String,Integer>> aList = new LinkedList<Entry<String,Integer>>(mapEntries);
 
        // sorting the List
        Collections.sort(aList, new Comparator<Entry<String,Integer>>() {
 
            @Override
            public int compare(Entry<String, Integer> ele1,
                    Entry<String, Integer> ele2) {
 
                return ele1.getValue().compareTo(ele2.getValue());
            }
        });
 
        // Storing the list into Linked HashMap to preserve the order of insertion. 
        Map<String,Integer> aMap2 = new LinkedHashMap<String, Integer>();
        for(Entry<String,Integer> entry: aList) {
            aMap2.put(entry.getKey(), entry.getValue());
        }
 
        // printing values after soring of map
        System.out.println("Value " + " - " + "Key");
        for(Entry<String,Integer> entry : aMap2.entrySet()) {
            System.out.println(entry.getValue() + " - " + entry.getKey());
        }
 
    }
}