Map接口方法一览

image-20220830092231621

以下方法均以Map接口实现类HashMap演示，因为这些方法对实现了Map接口的所有实体类都适用

1
Map<String, String> map = new HashMap(10);

put

put 方法用于将(K,V)键值对放入Map集合中

返回旧值

首次插入时旧值为null，之后value存在就返回这个插入之前的value

1
2
3
4
5
6
7
8
// 将一个K为name，V为ikun的键值对放入Map中
// 这里放入前name对应的值为null，返回null
System.out.println(A.put("name", "ikun"));
// 这里放入前name对应的值为ikun，返回ikun
System.out.println(A.put("name", "ikun"));
// 输出结果
// null
// ikun

get

取出K在Map集合中对应的V

1
2
3
4
// 取出K为name的V,并打印在终端上
System.out.println("name: " + map.get("name"));
// 结果如下
// name: ikun

putall

将一个Map集合（这里称为A集合）中所有的(K,V)键值对放入另外一个Map集合中（这里称为B集合）

注意：这里A集合中的键值对并不会消失

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// A集合
Map<String, String> A = new HashMap<>(10);
// 向A集合中放入4个(K,V)键值对
A.put("name", "ikun");
A.put("age", "18");
A.put("height", "180cm");
A.put("weight", "70kg");
// B集合
Map<String, String> B = new HashMap<>(10);
// 将A集合所有的(K,V)键值对放入B集合中
B.putAll(A);
// 打印A集合和B集合的toString字符串
System.out.println(A);
System.out.println(B);
// 结果如下
// {name=ikun, weight=70kg, age=18, height=180cm}
// {name=ikun, weight=70kg, age=18, height=180cm}

size

返回Map集合中(K,V)键值对的个数

1
2
3
4
// 输出A集合中(K,V)键值对的个数
System.out.println(A.size());
// 结果如下
// 4

isEmpty

判断Map集合是否为空

空则返回true，不空则返回false

1
2
3
4
5
6
7
8
9
10
11
// 判断A集合是否为空
System.out.println(A.isEmpty());
// 结果如下
// false

// 定义一个空的Map集合C
Map<String, String> C = new HashMap<>(10);
// 判断C集合是否为空
System.out.println(C.isEmpty());
// 结果如下
// true

containsKey

判断Map集合中是否存在指定Key

存在返回true，不存在返回false

1
2
3
4
5
6
7
// 判断A集合是否存在name键
System.out.println(A.containsKey("name"));
// 判断A集合是否存在hobby键
System.out.println(A.containsKey("hobby"));
// 结果如下
// true
// false

containsValue

判断Map集合中是否存在指定Value

存在返回true，不存在返回false

1
2
3
4
5
6
7
// 判断A集合是否存在ikun的值
System.out.println(A.containsValue("ikun"));
// 判断A集合是否存在rap的值
System.out.println(A.containsValue("rap"));
// 结果如下
// true
// false

remove

用于移除Map集合中指定的(K,V)键值对

该方法有两个重载

  1. String remove(Object key)

    用于移除指定Key对应的键值对，返回移除键值对的Value

  2. boolean remove(Object key, Object value)

​ 用于移除指定(key,value)键值对，移除成功返回true，移除失败返回false

​ 当且仅当键值对(key,value)存在时才能移除成功

1
2
3
4
5
6
7
8
9
// 移除A集合Key为weight的键值对
System.out.println(A.remove("weight"));
// 输出结果：70kg
// 移除A集合键值对("age", "18")
System.out.println(A.remove("age", "18"));
// 输出结果：true
// 移除A集合键值对("name", "xiaoming"),这个键值对在A集合中不存在
System.out.println(A.remove("name", "xiaoming"));
// 输出结果：false

replace

用于修改Map集合(K,V)键值对K对应的V

该方法有两个重载

  1. String replace(String key, String value)

    key指定修改哪个键值对，value为键值对(K,V)的V修改后的值

    返回值为修改前key对应的value字符串

  2. boolean replace(String key, String oldValue, String newValue)

​ 指定修改Map集合中(key, oldValue)为(key, newValue)

​ 当且仅当(key, oldValue)存在时才可修改成功

​ 修改成功返回true，修改失败返回false

1
2
3
4
5
6
7
// 修改B集合中以"name"为键的键值对的value为"小明"
System.out.println(B.replace("name", "小明"));
// 输出结果：ikun

// 修改B集合中的("name", "小明")为("name", "ikun")
System.out.println(B.replace("name", "小明", "ikun"));
// 输出结果：true

keySet

得到Map集合中key的集合

1
2
3
4
5
6
// 得到A集合中的key集合
Set<String> keys = B.keySet();
// 输出keys的toString
System.out.println(keys);
// 输出结果
// [name, weight, age, height]

values

得到Map集合中value的集合

1
2
3
4
5
6
// 得到B集合中的values集合
Collection<String> values = B.values();
// 输出values的toString
System.out.println(values);
// 输出结果
// [ikun, 70kg, 18, 180cm]

entrySet

得到map集合的entrySet

1
2
3
4
5
6
// 得到B集合的entrySet
Set<Map.Entry<String, String>> entrySet = B.entrySet();
// 打印B集合的entrySet
System.out.println(entrySet);
// 输出结果
// [name=ikun, weight=70kg, age=18, height=180cm]

hashCode

返回Map集合的hashCode

1
2
3
4
// 打印B集合的hashCode 
System.out.println(B.hashCode());
// 输出结果
// -2034218935

putIfAbsent

和put一样，用于将(K,V)键值对放入Map集合中

但是putIfAbsent只会在(K,V)键值对不存在于Map集合中时才能放入，这时返回null

(K,V)键值对存在时不能放入，这时返回已经存在的V

1
2
3
4
5
6
7
// 放入("hobby", "rap")键值对,放入成功
System.out.println(B.putIfAbsent("hobby", "rap"));
// 放入("name", "小明")键值对，放入失败，因为已经存在("name", "ikun")键值对
System.out.println(B.putIfAbsent("name", "小明"));
// 输出结果
// null
// ikun

getOrDefault

对不存在于Map集合中的(K,V)键值对提供默认值

1
2
3
4
5
6
7
// 设置sex的默认值为男
// 此时sex对应的键值对不存在，输出默认值"男"
System.out.println(B.getOrDefault("sex", "男"));
// 设置sex对应的键值对("sex", "女")
B.put("sex", "女");
// 此时因为sex键存在所以直接输出"女"而不是默认值"男"
System.out.println(B.getOrDefault("sex", "男"));

equals

判断两个Map集合是否相等

包括键值对个数和Map集合中的键值对要相等

结果证明：如果Map集合满足键值对个数和Map集合中的键值对相同，它们的hashCode也是一样的

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
// 定义三个Map集合
Map<String, String> A = new HashMap<>(10);
Map<String, String> B = new HashMap<>(10);
Map<String, String> C = new HashMap<>(10);
// 放入键值对
A.put("name", "ikun");
A.put("age", "18");
A.put("height", "180cm");
A.put("weight", "70kg");
B.put("name", "ikun");
B.put("age", "18");
B.put("height", "180cm");
B.put("weight", "70kg");
C.put("name", "ikun");
C.put("age", "18");
C.put("height", "180cm");
C.put("weight", "70kg");
// 打印集合键值对和hashCode
System.out.println("A: " + A + " hashCode = " + A.hashCode());
System.out.println("B: " + B + " hashCode = " + B.hashCode());
System.out.println("C: " + C + " hashCode = " + C.hashCode());
// 判断集合间是否相等
System.out.println("A equals B? " + A.equals(B));
System.out.println("A equals C? " + A.equals(C));
System.out.println("B equals C? " + B.equals(C));
// 输出结果
// A: {name=ikun, weight=70kg, age=18, height=180cm} hashCode = -2034218935
// B: {name=ikun, weight=70kg, age=18, height=180cm} hashCode = -2034218935
// C: {name=ikun, weight=70kg, age=18, height=180cm} hashCode = -2034218935
// A equals B? true
// A equals C? true
// B equals C? true

clear

清空集合中所有的键值对

结果证明：Map中的hashCode随键值对变化而变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 定义D集合·
Map<String, String> D = new HashMap<>(10);
// 放入键值对
D.put("name", "ikun");
D.put("age", "18");
D.put("height", "180cm");
D.put("weight", "70kg");
// 打印D的键值对和hashCode
System.out.println("D: " + D + " hashCode = " + D.hashCode());
// 清空所有键值对
D.clear();
// 打印D的键值对和hashCode
System.out.println("D: " + D + " hashCode = " + D.hashCode());
// 输出结果
// D: {name=ikun, weight=70kg, age=18, height=180cm} hashCode = -2034218935
// D: {} hashCode = 0