Java之Map集合

一、Map

Map是java中的接口，Map.Entry是Map的一个内部接口。

Map提供了一些常用方法，如keySet()、entrySet()等方法。

keySet()方法返回值是Map中key值的集合；entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。

Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。

Map<String, String> map = new HashMap<String, String>();
map.put(“key1”, “value1”);
map.put(“key2”, “value2”);
map.put(“key3”, “value3”);

二、遍历

//第一种：普遍使用，二次取值

System.out.println(“通过Map.keySet遍历key和value：”);
for (String key : map.keySet()) {
　　System.out.println("key= "+ key + " and value= " + map.get(key));
}

//第二种

System.out.println(“通过Map.entrySet使用iterator遍历key和value：”);
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
　　Map.Entry<String, String> entry = it.next();
　　System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

//第三种：推荐，尤其是容量大时

System.out.println(“通过Map.entrySet遍历key和value”);
for (Map.Entry<String, String> entry : map.entrySet()) {
　　System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

//第四种

System.out.println(“通过Map.values()遍历所有的value，但不能遍历key”);
for (String v : map.values()) {
    System.out.println("value= " + v);
}

三、排序

 1 import java.util.Collections;
 2 import java.util.HashMap;
 3 import java.util.LinkedHashMap;
 4 import java.util.Map;
 5  
 6 import static java.util.Map.Entry.comparingByValue;
 7 import static java.util.stream.Collectors.toMap;
 8  
 9 public class SortTest {
10  
11     public static void main(String[] args) throws Exception {
12  
13         // 创建一个字符串为Key，数字为值的map
14         Map<String, Integer> budget = new HashMap<>();
15         budget.put("clothes", 120);
16         budget.put("grocery", 150);
17         budget.put("transportation", 100);
18         budget.put("utility", 130);
19         budget.put("rent", 1150);
20         budget.put("miscellneous", 90);
21         System.out.println("排序前: " + budget);
22  
23         // 按值排序 升序
24         Map<String, Integer> sorted = budget
25                 .entrySet()
26                 .stream()
27                 .sorted(comparingByValue())
28                 .collect(
29                         toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
30                                 LinkedHashMap::new));
31  
32         System.out.println("升序按值排序后的map: " + sorted);
33  
34         // 按值排序降序
35         sorted = budget
36                 .entrySet()
37                 .stream()
38                 .sorted(Collections.reverseOrder(comparingByValue()))
39                 .collect(
40                         toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
41                                 LinkedHashMap::new));
42  
43         System.out.println("降序按值排序后的map: " + sorted);
44     }
45  
46  
47 }

封装成工具类

 1 /**
 2  * Map排序工具类
 3  *
 4  * 5  */
 6 public class MapSortUtil {
 7     
 8     private static Comparator<Map.Entry> comparatorByKeyAsc = (Map.Entry o1, Map.Entry o2) -> {
 9         if (o1.getKey() instanceof Comparable) {
10             return ((Comparable) o1.getKey()).compareTo(o2.getKey());
11         }
12         throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
13     };
14  
15  
16     private static Comparator<Map.Entry> comparatorByKeyDesc = (Map.Entry o1, Map.Entry o2) -> {
17         if (o1.getKey() instanceof Comparable) {
18             return ((Comparable) o2.getKey()).compareTo(o1.getKey());
19         }
20         throw new UnsupportedOperationException("键的类型尚未实现Comparable接口");
21     };
22  
23  
24     private static Comparator<Map.Entry> comparatorByValueAsc = (Map.Entry o1, Map.Entry o2) -> {
25         if (o1.getValue() instanceof Comparable) {
26             return ((Comparable) o1.getValue()).compareTo(o2.getValue());
27         }
28         throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
29     };
30  
31  
32     private static Comparator<Map.Entry> comparatorByValueDesc = (Map.Entry o1, Map.Entry o2) -> {
33         if (o1.getValue() instanceof Comparable) {
34             return ((Comparable) o2.getValue()).compareTo(o1.getValue());
35         }
36         throw new UnsupportedOperationException("值的类型尚未实现Comparable接口");
37     };
38  
39     /**
40      * 按键升序排列
41      */
42     public static <K, V> Map<K, V> sortByKeyAsc(Map<K, V> originMap) {
43         if (originMap == null) {
44             return null;
45         }
46         return sort(originMap, comparatorByKeyAsc);
47     }
48  
49     /**
50      * 按键降序排列
51      */
52     public static <K, V> Map<K, V> sortByKeyDesc(Map<K, V> originMap) {
53         if (originMap == null) {
54             return null;
55         }
56         return sort(originMap, comparatorByKeyDesc);
57     }
58  
59  
60     /**
61      * 按值升序排列
62      */
63     public static <K, V> Map<K, V> sortByValueAsc(Map<K, V> originMap) {
64         if (originMap == null) {
65             return null;
66         }
67         return sort(originMap, comparatorByValueAsc);
68     }
69  
70     /**
71      * 按值降序排列
72      */
73     public static <K, V> Map<K, V> sortByValueDesc(Map<K, V> originMap) {
74         if (originMap == null) {
75             return null;
76         }
77         return sort(originMap, comparatorByValueDesc);
78     }
79  
80     private static <K, V> Map<K, V> sort(Map<K, V> originMap, Comparator<Map.Entry> comparator) {
81         return originMap.entrySet()
82                 .stream()
83                 .sorted(comparator)
84                 .collect(
85                         Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
86                                 LinkedHashMap::new));
87     }
88  
89 }

 1 package com.chujianyun.common.map;
 2  
 3 import org.junit.jupiter.api.BeforeAll;
 4 import org.junit.jupiter.api.Test;
 5 import org.junit.jupiter.api.TestInstance;
 6  
 7 import java.util.HashMap;
 8 import java.util.Map;
 9  
10  
11 /**
12  * Map排序工具类
13  *
14  */
15 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
16 class MapSortUtilTest {
17     // 创建一个字符串为Key，数字为值的map
18     Map<String, Integer> budget = new HashMap<>();
19  
20     @BeforeAll
21     public void init() {
22         budget.put("clothes", 120);
23         budget.put("grocery", 150);
24         budget.put("transportation", 100);
25         budget.put("utility", 130);
26         budget.put("rent", 1150);
27         budget.put("miscellneous", 90);
28         System.out.println("排序前: " + budget);
29     }
30  
31     @Test
32     void sortByKeyAsc() {
33         System.out.println("按键升序" + MapSortUtil.sortByKeyAsc(budget));
34     }
35  
36     @Test
37     void sortByKeyDesc() {
38         System.out.println("按键降序" + MapSortUtil.sortByKeyDesc(budget));
39     }
40  
41     @Test
42     void sortByValueAsc() {
43         System.out.println("按值升序" + MapSortUtil.sortByValueAsc(budget));
44     }
45  
46     @Test
47     void sortByValueDesc() {
48         System.out.println("按值降序" + MapSortUtil.sortByValueDesc(budget));
49     }
50 }

posted @ 2022-06-25 22:32 昂昂呀阅读(92) 评论(0) 收藏举报

刷新页面返回顶部

好好学习，天天向上

Java之Map集合

一、Map

二、遍历

三、排序

公告