1
//---------------------------新增，删除，查找数据接口
2
//    V put(K key, V value): 添加键值对。 如果键存在，是更新数据
3
//    void putAll(Map<? extends K,? extends V> m)： 将一个map的所有键值对都放入这个map
4
//    V get(Object key)： 根据一个key，获取value，如果key不存在，返回null
5
//    V remove(Object key)： 删除map中所包含的这个key
6

7
//    boolean containsKey(Object key): 判断map中是否包含这个key
8
//    boolean containsValue(Object value): 判断map中是否包含这个value
9

10
// getOrDefault(Object key,Object value)
11
// 如果存在，就返回对应的值；  如果不存在，就返回默认值
12

13
//---------------------------辅助接口
14
//    void clear() : 清空map
15
//    boolean equals(Object o)： 判断两个map是否相等
16
//    int hashCode(): 返回此映射的哈希码值。
17
//    boolean isEmpty(): map中是否有元素
18
//    int size() ：返回键-值映射关系数。
19

20
//---------------------------视图方法。  遍历方法
21
// 在Map里面 Entry 代表存储了key和value的一个接口体
22
//    Set<Map.Entry<K,V>> entrySet()： 返回此映射中包含的映射关系的 Set 视图。
23
//    Set<K> keySet()： 返回此映射中包含的键的 Set 视图。
24
//    Collection<V> values()： 返回此映射中包含的值的 Collection 视图。

1
    private static List<Student> generateStudents() {
2
        List<Student> students = new ArrayList<>();
3

4
        // Arrays.asList（） 就是近似这样理解
5
        // list = new ArrayList();   list.add("hubei"); list.add("hunan");    list.add("guangdong")
6
        List<String> provinceList = Arrays.asList("hubei", "hunan", "guangdong");
7

8
        for (int i = 0; i < 50; i++) {
9
            Student student = new Student();
10
            student.setName("student" + i);
11
            student.setAge(15);
12
            // 从省份的list中，获取出一个省份，设置到学生上
13
            String province = provinceList.get(i % 3);
14
            student.setProvince(province);
15

16
            students.add(student);
17
        }
18

19
        return students;
20
    }

1
//---------------------------新增，删除，查找数据接口
2
//    V put(K key, V value): 添加键值对
3
//    void putAll(Map<? extends K,? extends V> m)： 将一个map的所有键值对都放入这个map
4
//    V get(Object key)： 根据一个key，获取value，如果key不存在，返回null
5
//    V remove(Object key)： 删除map中所包含的这个key
6

7
//    boolean containsKey(Object key): 判断map中是否包含这个key
8
//    boolean containsValue(Object value): 判断map中是否包含这个value
9

10
//---------------------------辅助接口
11
//    void clear() : 清空map
12
//    boolean equals(Object o)： 判断两个map是否相等
13
//    int hashCode(): 返回此映射的哈希码值。
14
//    boolean isEmpty(): map中是否有元素
15
//    int size() ：返回键-值映射关系数。
16

17
//---------------------------视图方法
18
//    Set<Map.Entry<K,V>> entrySet()： 返回此映射中包含的映射关系的 Set 视图。
19
//    Set<K> keySet()： 返回此映射中包含的键的 Set 视图。
20
//    Collection<V> values()： 返回此映射中包含的值的 Collection 视图。

1
// 一组学生数据，学生信息里有以下信息。
2
// (id, name, age, teacher_id)
3

4
// 一组班主任数据，有以下信息
5
// (id, name, age)
6

7
// 我们这样认为：一个老师对应n个学生，一个学生只对应一个老师。
8
// 现在需求方需要一个数据，需要返回 班主任的信息，然后和对应班级同学的信息。
9
// 提供两份数据：
10
//        List<Teacher> teachers = new ArrayList<>();
11
//        List<Student> students = new ArrayList<>();
12

13
class Grade{
14
   Teacher teacher;
15
   List<Student> students;
16
}

1
//---------------------------新增，删除，查找数据接口
2
//    V put(K key, V value): 添加键值对
3
//    void putAll(Map<? extends K,? extends V> m)： 将一个map的所有键值对都放入这个map
4
//    V get(Object key)： 根据一个key，获取value，如果key不存在，返回null
5
//    V remove(Object key)： 删除map中所包含的这个key
6

7
//    boolean containsKey(Object key): 判断map中是否包含这个key
8
//    boolean containsValue(Object value): 判断map中是否包含这个value
9

10
//---------------------------辅助接口
11
//    void clear() : 清空map
12
//    boolean equals(Object o)： 判断两个map是否相等
13
//    int hashCode(): 返回此映射的哈希码值。
14
//    boolean isEmpty(): map中是否有元素
15
//    int size() ：返回键-值映射关系数。
16

17
//---------------------------视图方法
18
//    Set<Map.Entry<K,V>> entrySet()： 返回此映射中包含的映射关系的 Set 视图。
19
//    Set<K> keySet()： 返回此映射中包含的键的 Set 视图。
20
//    Collection<V> values()： 返回此映射中包含的值的 Collection 视图。

1
   // ----------------------从Map接口继承来的----------------------------
2
//        boolean containsKey(Object key)
3
//        如果此映射包含指定键的映射关系，则返回 true。
4
//        boolean containsValue(Object value)
5
//        如果此映射为指定值映射一个或多个键，则返回 true。
6
//        V put(K key, V value)
7
//        将指定值与此映射中的指定键进行关联。
8
//        void putAll(Map<? extends K,? extends V> map)
9
//        将指定映射中的所有映射关系复制到此映射中。
10
//        V remove(Object key)
11
//        如果此 TreeMap 中存在该键的映射关系，则将其删除。
12
//        V get(Object key)
13
//        返回指定键所映射的值，如果对于该键而言，此映射不包含任何映射关系，则返回 null。
14

15

16
//        void clear()
17
//        从此映射中移除所有映射关系。
18
//        Object clone()
19
//        返回此 TreeMap 实例的浅表副本。
20
//        int size()
21
//        返回此映射中的键-值映射关系数。
22

23

24
//        Collection<V> values()
25
//        返回此映射包含的值的 Collection 视图。
26
//        Set<K> keySet()
27
//        返回此映射包含的键的 Set 视图。
28
//        Set<Map.Entry<K,V>> entrySet()
29
//        返回此映射中包含的映射关系的 Set 视图。
30

31
        // ------------------------TreeMap定义大小操作相关的api------------------------
32
//        Map.Entry<K,V> ceilingEntry(K key): 大于等于给定key的最小键值对
33
//        K ceilingKey(K key): 大于等于给定key的最小key
34
//        Map.Entry<K,V> floorEntry(K key): 小于等于key的最大的键值对
35
//        K floorKey(K key): 小于等于key最大的key
36
//        Map.Entry<K,V> higherEntry(K key): 大于给定key的最小键值对
37
//        K higherKey(K key): 大于给定key的最小key
38
//        Map.Entry<K,V> lowerEntry(K key): 小于key的最大的键值对
39
//        K lowerKey(K key): 小于key最大的key
40

41
//        Map.Entry<K,V> firstEntry(): 返回最小的键值对
42
//        K firstKey(): 返回最小的key
43
//        Map.Entry<K,V> lastEntry(): 返回最大的键值对
44
//        K lastKey(): 返回最大的key
45

46
//        Map.Entry<K,V> pollFirstEntry(): 删除最小的键值对
47
//        Map.Entry<K,V> pollLastEntry(): 删除最大的键值对
48

49

50
        // ---------------------视图方法-----------------------------
51
//        NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
52
//        返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
53
//        SortedMap<K,V> subMap(K fromKey, K toKey)
54
//        返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
55
//        SortedMap<K,V> tailMap(K fromKey)
56
//        返回此映射的部分视图，其键大于等于 fromKey。
57
//        NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
58
//        返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
59
//        SortedMap<K,V> headMap(K toKey)
60
//        返回此映射的部分视图，其键值严格小于 toKey。
61
//        NavigableMap<K,V> headMap(K toKey, boolean inclusive)
62
//        返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
63

64
        // -------------------------一些特殊的api: 了解-------------------------------
65
//        NavigableSet<K> descendingKeySet()
66
//        返回此映射中所包含键的逆序 NavigableSet 视图。
67
//        NavigableMap<K,V> descendingMap()
68
//        返回此映射中所包含映射关系的逆序视图。
69
//        NavigableSet<K> navigableKeySet()
70
//        返回此映射中所包含键的 NavigableSet 视图。
71
//        Comparator<? super K> comparator()
72
//        返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。