9 分钟 读完 (大约 1288 个字)  0次访问

Java-Map

Java-Map

受到上篇C++ STL中map的排序方式的启发，这次又来探究一下Java中对于map的不同排序方式

依然分为两种排序

  • Sort By Key
  • Sort By Value

打印map

打印map的元素使用以下的show()方法：

1
2
3
4
5
6
7
public static void show(Map<String, Integer> map) {
    for (Map.Entry<String, Integer> entry: map.entrySet()) {
        System.out.println(entry.getKey() + "  " + entry.getValue());
    }
    System.out.println("=======================");
    System.out.println();
}

Sort By Value

升序

Java中对于Map的value进行排序依然需要借助其他容器，这里使用ArrayList

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
   /**
    * 获取按照value升序排序后的map
    * @param map 需要排序的map
    * @return 排好序的map
    */
   public static Map<String, Integer> sortByValueAsc(Map<String, Integer> map) {
       List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
       // 升序
       Collections.sort(list, (e1, e2) -> e1.getValue().compareTo(e2.getValue()));
       Map<String, Integer> sortedMap = new LinkedHashMap<>();
       for (Map.Entry<String, Integer> entry: list) {
           sortedMap.put(entry.getKey(), entry.getValue());
       }
       return sortedMap;
   }

public static void main(String[] args) {
       Map<String, Integer> map = new HashMap<>();
       map.put("boss", 2);
       map.put("abuse", 1);
       map.put("unit", 3);
       map.put("duty", 4);

       // 根据Value升序排序
       System.out.println("🚀 SORT BY VALUE ASC:");
       Map<String, Integer> sortedMapAsc = sortByValueAsc(map);
       show(sortedMapAsc);
}

这里将Map中的entry都放到了一个List中，然后使用自定义Comparator的方式对entry进行排序；

同时也使用了一种新的Map–LinkedHashMap

LinkedHashMap是有序的，它会按照元素的插入顺序对元素进行排序

结果如下:

1
2
3
4
5
6
🚀 SORT BY VALUE ASC:
abuse  1
boss  2
unit  3
duty  4
=======================

降序

同理，只是更换一下Comparator：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
   * 获取按照value降序排序后的map
   * @param map 需要排序的map
   * @return 排好序的map
   */
  public static Map<String, Integer> sortByValueDesc(Map<String, Integer> map) {
      List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
      // 降序
      Collections.sort(list, (e1, e2) -> e2.getValue().compareTo(e1.getValue()));
      Map<String, Integer> sortedMap = new LinkedHashMap<>();
      for (Map.Entry<String, Integer> entry: list) {
          sortedMap.put(entry.getKey(), entry.getValue());
      }
      return sortedMap;
  }

	public static void main(String[] args) {
      Map<String, Integer> map = new HashMap<>();
      map.put("boss", 2);
      map.put("abuse", 1);
      map.put("unit", 3);
      map.put("duty", 4);

      // 根据Value降序排序
      System.out.println("🚀 SORT BY VALUE DESC");
      Map<String, Integer> sortedMapDesc = sortByValueDesc(map);
      show(sortedMapDesc);
  }

结果如下:

1
2
3
4
5
6
🚀 SORT BY VALUE DESC
duty  4
unit  3
boss  2
abuse  1
=======================

Sort By Key

升序

对于key的排序也可以按照对value的排序一样，借助ArrayList和LinkedHashMap，但这里采用另一种方式，借助TreeMap进行排序

TreeMap是另一种Map，会对Map中的元素按照key大小进行排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
  /**
   * 通过TreeMap的方式对key按照升序排序
   * @param map 要排序的map
   * @return  按照key升序排好序的map
   */
  public static Map<String, Integer> sortByKeyByTreeMapAsc(Map<String, Integer> map) {
      /*
      The naturalOrder() method of Comparator Interface in Java
      returns a comparator that use to compare Comparable objects in natural order.
       */
      Map<String, Integer> sortedMap = new TreeMap<>(Comparator.naturalOrder());
      sortedMap.putAll(map);
      return sortedMap;
  }

public static void main(String[] args) {
      Map<String, Integer> map = new HashMap<>();
      map.put("boss", 2);
      map.put("abuse", 1);
      map.put("unit", 3);
      map.put("duty", 4);


      // 根据Key升序排序，使用TreeMap方式
      System.out.println("🚀 SORT BY KEY ASC");
      Map<String, Integer> sortedByKeyAsc = sortByKeyByTreeMapAsc(map);
      show(sortedByKeyAsc);
  }

对Comparable对象的升序排序可以使用Comparator.naturalOrder()返回的Comparator来指定

执行的结果如下:

1
2
3
4
5
6
🚀 SORT BY KEY ASC
abuse  1
boss  2
duty  4
unit  3
=======================

降序

同理，只是需要更改Comparator：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * 通过TreeMap的方式对key按照将序排序
 * @param map 要排序的map
 * @return  按照key降序排好序的map
 */
public static Map<String, Integer> sortByKeyByTreeMapDesc(Map<String, Integer> map) {
    /*
    The reverseOrder() Returns a comparator that imposes the reverse of the natural ordering.
     */
    Map<String, Integer> sortedMap = new TreeMap<>(Comparator.reverseOrder());
    sortedMap.putAll(map);
    return sortedMap;
}

public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<>();
    map.put("boss", 2);
    map.put("abuse", 1);
    map.put("unit", 3);
    map.put("duty", 4);

    // 根据Key降序排序，使用TreeMap方式
    System.out.println("🚀 SORT BY KEY DESC");
    Map<String, Integer> sortedByKeyDesc = sortByKeyByTreeMapDesc(map);
    show(sortedByKeyDesc);

}

对Comparable对象的降序排序可以使用Comparator.reverseOrder()返回的Comparator来指定

结果如下:

1
2
3
4
5
6
🚀 SORT BY KEY DESC
unit  3
duty  4
boss  2
abuse  1
=======================

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import java.util.*;

/**
 * @author HavenTong
 * @date 2020/3/5 5:34 下午
 */
public class MapUtil {

    public static void show(Map<String, Integer> map) {
        for (Map.Entry<String, Integer> entry: map.entrySet()) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
        System.out.println("=======================");
        System.out.println();
    }

    /**
     * 获取按照value升序排序后的map
     * @param map 需要排序的map
     * @return 排好序的map
     */
    public static Map<String, Integer> sortByValueAsc(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
        // 升序
        Collections.sort(list, (e1, e2) -> e1.getValue().compareTo(e2.getValue()));
        Map<String, Integer> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<String, Integer> entry: list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        return sortedMap;
    }

    /**
     * 获取按照value降序排序后的map
     * @param map 需要排序的map
     * @return 排好序的map
     */
    public static Map<String, Integer> sortByValueDesc(Map<String, Integer> map) {
        List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
        // 降序
        Collections.sort(list, (e1, e2) -> e2.getValue().compareTo(e1.getValue()));
        Map<String, Integer> sortedMap = new LinkedHashMap<>();
        for (Map.Entry<String, Integer> entry: list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        return sortedMap;
    }


    /**
     * 通过TreeMap的方式对key按照升序排序
     * @param map 要排序的map
     * @return  按照key升序排好序的map
     */
    public static Map<String, Integer> sortByKeyByTreeMapAsc(Map<String, Integer> map) {
        /*
        The naturalOrder() method of Comparator Interface in Java
        returns a comparator that use to compare Comparable objects in natural order.
         */
        Map<String, Integer> sortedMap = new TreeMap<>(Comparator.naturalOrder());
        sortedMap.putAll(map);
        return sortedMap;
    }

    /**
     * 通过TreeMap的方式对key按照将序排序
     * @param map 要排序的map
     * @return  按照key降序排好序的map
     */
    public static Map<String, Integer> sortByKeyByTreeMapDesc(Map<String, Integer> map) {
        /*
        The reverseOrder() Returns a comparator that imposes the reverse of the natural ordering.
         */
        Map<String, Integer> sortedMap = new TreeMap<>(Comparator.reverseOrder());
        sortedMap.putAll(map);
        return sortedMap;
    }



    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("boss", 2);
        map.put("abuse", 1);
        map.put("unit", 3);
        map.put("duty", 4);

        // 根据Value升序排序
        System.out.println("🚀 SORT BY VALUE ASC:");
        Map<String, Integer> sortedMapAsc = sortByValueAsc(map);
        show(sortedMapAsc);

        // 根据Value降序排序
        System.out.println("🚀 SORT BY VALUE DESC");
        Map<String, Integer> sortedMapDesc = sortByValueDesc(map);
        show(sortedMapDesc);

        // 根据Key升序排序，使用TreeMap方式
        System.out.println("🚀 SORT BY KEY ASC");
        Map<String, Integer> sortedByKeyAsc = sortByKeyByTreeMapAsc(map);
        show(sortedByKeyAsc);

        // 根据Key降序排序，使用TreeMap方式
        System.out.println("🚀 SORT BY KEY DESC");
        Map<String, Integer> sortedByKeyDesc = sortByKeyByTreeMapDesc(map);
        show(sortedByKeyDesc);

    }
}
#

喜欢这篇文章？打赏一下作者吧

评论

×