java map按key排序 map 排序 java

Java基础知识之Map集合的排序操作

　　要实现Map的排序功能,需要借助Comparable接口的compareTo方法进行对比,比较的思路是把map转换成一个Set集合,然后通过转换成Stream(流),来使用它的sort方法,进行排序,最后通过Collectors.toMap()方法来把结果返回来.

map集合排序工具类:

1 public class MapSortUtil {
  2     private static Comparator<Map.Entry> comparatorByKeyAsc = (Map.Entry o1,Map.Entry o2)->{
  3         if (o1.getKey() instanceof Comparable){
  4             return ((Comparable) o1.getKey()).compareTo(o2.getKey());
  5         }
  6         throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
  7     };
  8 
  9     private static Comparator<Map.Entry> comparatorByKeyDesc = (Map.Entry o1,Map.Entry o2) ->{
 10         if (o1.getKey() instanceof Comparable){
 11             return ((Comparable) o2.getKey()).compareTo(o1.getKey());
 12         }
 13         throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
 14     };
 15 
 16     private static Comparator<Map.Entry> comparatorByValueAsc = (Map.Entry o1,Map.Entry o2) ->{
 17         if (o1.getValue() instanceof Comparable){
 18             return ((Comparable) o1.getValue()).compareTo(o2.getValue());
 19         }
 20         throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
 21     };
 22 
 23     private static Comparator<Map.Entry> comparatorByValueDesc = (Map.Entry o1,Map.Entry o2) ->{
 24         if (o1.getValue() instanceof Comparable){
 25             return ((Comparable) o2.getValue()).compareTo(o1.getValue());
 26         }
 27         throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
 28     };
 29 
 30     /**
 31      * 按键升序排列
 32      * @param originMap
 33      * @param <K>
 34      * @param <V>
 35      * @return
 36      */
 37     public static <K, V> Map<K, V> sortByKeyAsc(Map<K, V> originMap) {
 38         if (originMap == null) {
 39             return null;
 40         }
 41         return sort(originMap, comparatorByKeyAsc);
 42     }
 43 
 44     /**
 45      * 按键降序排列
 46      * @param originMap
 47      * @param <K>
 48      * @param <V>
 49      * @return
 50      */
 51     public static <K, V> Map<K, V> sortByKeyDesc(Map<K, V> originMap) {
 52         if (originMap == null) {
 53             return null;
 54         }
 55         return sort(originMap, comparatorByKeyDesc);
 56     }
 57 
 58     /**
 59      * 按值升序排列
 60      * @param originMap
 61      * @param <K>
 62      * @param <V>
 63      * @return
 64      */
 65     public static <K, V> Map<K, V> sortByValueAsc(Map<K, V> originMap) {
 66         if (originMap == null) {
 67             return null;
 68         }
 69         return sort(originMap, comparatorByValueAsc);
 70     }
 71 
 72     /**
 73      * 按值降序排列
 74      * @param originMap
 75      * @param <K>
 76      * @param <V>
 77      * @return
 78      */
 79     public static <K, V> Map<K, V> sortByValueDesc(Map<K, V> originMap) {
 80         if (originMap == null) {
 81             return null;
 82         }
 83         return sort(originMap, comparatorByValueDesc);
 84     }
 85 
 86     /**
 87      * 排序逻辑的实现
 88      * @param originMap 需要排序的map集合
 89      * @param comparator 排序的方式
 90      * @param <K>
 91      * @param <V>
 92      * @return 返回一个排序好的map集合
 93      * stream方法:返回一个顺序Stream与此集合作为其来源。把集合操作改成流管道的操作.
 94      * sorted方法:返回由该流的元素组成的流，根据提供的 Comparator进行排序。
 95      * collect方法:流操作,使用 Collector对此流的元素执行 mutable reduction Collector 。
 96      * Collectors.toMap方法:返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。
 97      */
 98     private static <K, V> Map<K, V> sort(Map<K, V> originMap, Comparator<Map.Entry> comparator) {
 99         return originMap.entrySet()
100                 .stream()
101                 .sorted(comparator)
102                 .collect(
103                         Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
104                                 LinkedHashMap::new));
105     }
106 
107 }

测试类:

1 public class MapSortTest {
 2     public static void main(String[] args) {
 3         Map<String,String> map = new HashMap<>();
 4         map.put("1","java");
 5         map.put("2","python");
 6         map.put("3","c");
 7         map.put("4","c#");
 8         map.put("5","php");
 9         //开始对map进行排序
10         System.out.println("按键升序:"+MapSortUtil.sortByKeyAsc(map));
11         System.out.println();
12         System.out.println("按键降序:"+MapSortUtil.sortByKeyDesc(map));
13         System.out.println();
14         System.out.println("按值升序:"+MapSortUtil.sortByValueAsc(map));
15         System.out.println();
16         System.out.println("按值降序:"+MapSortUtil.sortByValueDesc(map));
17     }
18 }

测试结果: