今天我们分析一下集合框架的另一套体系，键值对的Map集合。
Map集合是用键值对作为存储元素的集合，所以它可以通过key值来操作集合中的键值对元素。
一. Map接口
public interface Map<K,V> {}
可以注意到Map接口是一个顶层接口，与Collection没有任何联系，甚至它都没有继承Iterable接口，说明Map是不可迭代的。但是Map集合提供了方法将集合中的元素转换成一个可迭代接口实例。
1.1 Map集合常用方法
那么Map接口应该提供哪些方法呢?
- 添加元素
// 向集合中添加 键值对,但是如果key值存在，就替换对应的value值
V put(K key, V value);
// 将集合m中的键值对全部存放到本集合中
void putAll(Map<? extends K, ? extends V> m);
- 删除元素
// 根据键key移除Map集合中对应的键值对, 并返回value值
V remove(Object key);
// 清除集合中所有的键值对
void clear();
- 替换元素
// 向集合中添加 键值对,但是如果key值存在，就替换对应的value值
V put(K key, V value);
- 查询方法
// Map集合键值对中是否包括这个键key
boolean containsKey(Object key);
// Map集合键值对中是否包括这个value值
boolean containsValue(Object value);
// 返回Map集合中所有的键组成的Set集合。因为键是唯一的，所以是Set集合
Set<K> keySet();
// 返回Map集合中所有的值组成的Collection集合。因为值是可以重复的。
Collection<V> values();
// 返回Map集合中所有的键值对组成的Set集合。因为键值对也是唯一的。
Set<Map.Entry<K, V>> entrySet();
// 通过键key获取对应的值
V get(Object key);
- 其他方法
// Map集合元素数量
int size();
// 集合是否为空
boolean isEmpty();
1.2 Map内部接口Entry
因为Map集合是用键值对储存元素的，所以它提供了键值对类的顶层接口Entry。它提供了三个重要方法
- K getKey(); 获取key值
- V getValue(); 获取value值
- V setValue(V value); 替换value值
Entry 提供了equals和hashCode方法，强制子类实现这个两个方法
// 比较两个Entry是否相等的方法
boolean equals(Object o);
// 因为复写了equals方法，必须复写hashCode方法。来保证相同的Entry 它们的hashCode值必须也是相同的
int hashCode();
它还提供四个静态方法，返回一个Comparator<Map.Entry<K,V>>比较器，用来比较两个Entry的大小的。
// 工具类方法， 返回一个根据key值大小的比较器Comparator。
// 调用Comparator的compare(T o1, T o2)方法，就可以比较两个Map.Entry大小，是根据Map.Entry的key值来判断的。
// 所以必须保证key值的类型是实现Comparable接口，来确保key值是可以比较的
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>>
comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
// 工具类方法，返回一个根据value值大小的比较器Comparator。
// 所以必须保证value值的类型是实现Comparable接口，来确保value值是可以比较的
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>>
comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
// 工具类方法，根据一个key值比较器Comparator<? super K> 生成一个 键值对比较器Comparator<Map.Entry<K, V>>
// 很简单，因为键值对比较器Comparator的compare(T o1, T o2)方法 参数类型是Map.Entry，
// 然后调用Map.Entry的getKey方法获取对应key值，然后调用key值比较器Comparator的compare方法就实现比较功能了。
public static <K, V> Comparator<Map.Entry<K, V>>
comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
// 工具类方法，根据一个value值比较器Comparator<? super V> 生成一个 键值对比较器Comparator<Map.Entry<K, V>>
public static <K, V> Comparator<Map.Entry<K, V>>
comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
1.3 Map接口提供默认实现方法
因为Map集合是用键值对存储的，所以Map接口提供了一些根据key值操作集合的默认实现方法，主要是键值对的删除和替换方法。
再说这些方法之前，我们想一个问题，操作这些键值对，有两种方法，一种是根据key值(也就是key值在集合中存在),另一种是根据键值对(也就是说不仅key值在集合中存在，而且value值也要相等)
- 怎么判断key值在集合中存在?
使用containsKey(key)方法返回true就行了。
但是有个问题，一般情况下我们都要得到key所对应的原value值，所以一般都是先调用V get(Object key)方法，然后再去调用containsKey(key)方法。
有人会说这不是傻么，不会先调用containsKey(key)方法，如果存在再调用get(Object key)方法么？这个就涉及到效率问题了，因为这两个方法都是遍历整个集合来查找对应的键值对，所以尽量不要同时使用这个两个方法。
这里就有一个小技巧了，get(Object key)返回值如果不是null，那么说明找到对应的键值对了，所以这个key值是包含的。
但是坑爹的是get(Object key)返回值是null，并不代表没有找到对应键值对，因为Map集合允许value值为null(甚至key值也允许为null)。所以还必须调用containsKey(key)方法进行二次循环遍历查找。
所以这个表示key值存在的判断式(((v = get(key)) != null) || containsKey(key))
- 怎么判断键值对相等?
先通过get(Object key)查找curValue值，然后判断这个curValue值与传入的value是否相等，不相等就直接返回。相等的话，就判断key值在集合中是否存在。 一般判断条件如下：
// 根据key值获取对应curValue值
Object curValue = get(key);
// 1. 如果值不相等，即!Objects.equals(curValue, value)为true，那么就直接返回false
// 2. 如果值相等，判断key值在集合中是否存在。
// (curValue == null && !containsKey(key)) 可以改写成
// !(curValue != null || containsKey(key))
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
package java.util;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.io.Serializable;
public interface Map<K,V> {
// 添加元素
// 向集合中添加 键值对,但是如果key值存在，就替换对应的value值
V put(K key, V value);
// 将集合m中的键值对全部存放到本集合中
void putAll(Map<? extends K, ? extends V> m);
// 删除元素
// 根据键key移除Map集合中对应的键值对, 并返回value值
V remove(Object key);
// 移除Map集合中键值与key相等 v值与value相等的键值对(而不是只要求key相等)
default boolean remove(Object key, Object value) {
// 根据key值获取对应curValue值
Object curValue = get(key);
// 1. 如果值不相等，即!Objects.equals(curValue, value)为true，那么就直接返回false
// 2. 如果值相等，判断key值在集合中是否存在。
// (curValue == null && !containsKey(key)) 可以改写成
// !(curValue != null || containsKey(key))
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
// 清除集合中所有的键值对
void clear();
// 更新元素
// 遍历集合中所有键值对元素， 通过BiFunction的apply方法，获取一个新的value值，然后替换键值对中的原来的value值
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
// 通过BiFunction的apply方法，获取一个新的value值，然后替换键值对中的原来的value值
v = function.apply(k, v);
try {
entry.setValue(v);
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
}
}
// 如果key值对应的v值为null，就将这个键值对中的v替换成新的value值。
// 如果key值对应的v值不为null，就不做替换操作
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
// 找到与key、oldValue相等的键值对，然后将这个键值对中的value值替换成新newValue
default boolean replace(K key, V oldValue, V newValue) {
Object curValue = get(key);
if (!Objects.equals(curValue, oldValue) ||
(curValue == null && !containsKey(key))) {
return false;
}
put(key, newValue);
return true;
}
// 找到与key值相等的键值对，然后将这个键值对中的curValue值替换成新value值，并返回原来的curValue值
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
// 如果Map集合不包含这个key值，或者key值对应的value为null，那么就调用mappingFunction的apply方法，
// 生成新的newValue值。将这个newValue值和key值存放到Map集合中。
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V v;
if ((v = get(key)) == null) {
V newValue;
// 注意 这里得到的新值不为null的时候，才添加到集合中
if ((newValue = mappingFunction.apply(key)) != null) {
put(key, newValue);
return newValue;
}
}
return v;
}
default V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue;
if ((oldValue = get(key)) != null) {
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
put(key, newValue);
return newValue;
} else {
remove(key);
return null;
}
} else {
return null;
}
}
default V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue = get(key);
V newValue = remappingFunction.apply(key, oldValue);
if (newValue == null) {
// delete mapping
if (oldValue != null || containsKey(key)) {
// something to remove
remove(key);
return null;
} else {
// nothing to do. Leave things as they were.
return null;
}
} else {
// add or replace old mapping
put(key, newValue);
return newValue;
}
}
default V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue, value);
if(newValue == null) {
remove(key);
} else {
put(key, newValue);
}
return newValue;
}
// 查询方法
// Map集合键值对中是否包括这个键key
boolean containsKey(Object key);
// Map集合键值对中是否包括这个value值
boolean containsValue(Object value);
// 返回Map集合中所有的键组成的Set集合。因为键是唯一的，所以是Set集合
Set<K> keySet();
// 返回Map集合中所有的值组成的Collection集合。因为值是可以重复的。
Collection<V> values();
// 返回Map集合中所有的键值对组成的Set集合。因为键值对也是唯一的。
Set<Map.Entry<K, V>> entrySet();
// 通过键key获取对应的值
V get(Object key);
// 根据key值获取Map集合中对应value值，如果没有获取到，就返回默认值defaultValue
default V getOrDefault(Object key, V defaultValue) {
V v;
// 这里还要调用containsKey方法，这是因为Map集合允许存放value值为空的键值对
// get(key)返回null，并不代表没有这个键值对(甚至key值都可以为null)。所以还要调用containsKey方法。
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
// Map集合元素数量
int size();
// 集合是否为空
boolean isEmpty();
// 比较两个Map集合是否相等的方法
boolean equals(Object o);
// 因为复写了equals方法，必须复写hashCode方法。来保证相同的Map集合 它们的hashCode值必须也是相同的
int hashCode();
// 遍历集合中所有键值对元素，使它们都调用action的accept方法
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
// 表示键值对实体的顶层接口。
// 它提供了获取键值getKey方法，获取value值的getValue方法，已经替换value值的setValue方法。
interface Entry<K,V> {
// 获取key值
K getKey();
// 获取value值
V getValue();
// 替换value值
V setValue(V value);
// 比较两个Entry是否相等的方法
boolean equals(Object o);
// 因为复写了equals方法，必须复写hashCode方法。来保证相同的Entry 它们的hashCode值必须也是相同的
int hashCode();
// 工具类方法， 返回一个根据key值大小的比较器Comparator。
// 调用Comparator的compare(T o1, T o2)方法，就可以比较两个Map.Entry大小，是根据Map.Entry的key值来判断的。
// 所以必须保证key值的类型是实现Comparable接口，来确保key值是可以比较的
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
// 工具类方法，返回一个根据value值大小的比较器Comparator。
// 所以必须保证value值的类型是实现Comparable接口，来确保value值是可以比较的
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
// 工具类方法，根据一个key值比较器Comparator<? super K> 生成一个 键值对比较器Comparator<Map.Entry<K, V>>
// 很简单，因为键值对比较器Comparator的compare(T o1, T o2)方法 参数类型是Map.Entry，
// 然后调用Map.Entry的getKey方法获取对应key值，然后调用key值比较器Comparator的compare方法就实现比较功能了。
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
// 工具类方法，根据一个value值比较器Comparator<? super V> 生成一个 键值对比较器Comparator<Map.Entry<K, V>>
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}
}
总结
Map接口不继承Collection接口，它与Collection没有任何联系。甚至它都没有继承Iterable接口，说明Map是不可迭代的。
操作元素
1. 添加元素
- V put(K key, V value); 向集合中添加 键值对,但是如果key值存在，就替换对应的value值。
- void putAll(Map<? extends K, ? extends V> m); 将集合m中的键值对全部存放到本集合中。
- 删除元素
- V remove(Object key); 根据键key移除Map集合中对应的键值对, 并返回value值
- void clear(); 清除集合中所有的键值对
注意 和Collection接口不一样，它没有提供removeAll以及retainAll的方法。
- 查询方法 中最主要的方法是Set<Map.Entry<K, V>> entrySet();返回键值对的Set集合，我们通过它才能遍历Map集合，因为Map集合本身是不支持遍历的。至于keySet集合以及values集合都是通过这个entrySet集合得到的。
Map内部接口Entry
提供键值对顶层接口Entry，具体实现交给子类。
主要是提供了访问键值对的三个重要方法：
- K getKey(); 获取key值。
- V getValue(); 获取value值
- V setValue(V value); 替换value值
Map接口提供默认实现方法
主要有两个方法需要理解：
- V get(Object key); 这个方法会遍历Map集合，寻找key相同的键值对元素，然后返回对应的value值，如果没有找到，就返回null。
所以我们可以断定如果返回值不为null，那么这个key值在Map集合中一定存在。但是坑爹的是如果返回为null，并不代表这个key值在Map集合中不存在，因为键值对的value 值是可以为null的。
- boolean containsKey(Object key); 如果key值在Map集合中存在就返回true，如果不存在就返回false。
这个方法可以判断key值在集合中是否存在，但是它有个缺陷，它不能返回key值对应的value值，有时候我们需要这个值，这个时候我们就必须调用V get(Object key)方法。这个两个方法都是遍历整个Map集合进行寻找，所以效率不高。
因此我们一般先调用 V get(Object key)方法，如果得到值不为null，那么这个key值在Map集合中存在，如果为null，再调用containsKey(Object key)方法。一般判断式(((v = get(key)) != null) || containsKey(key))
如果我们不单单比较key值，需要键值对都相等，操作流程如下：
- 先通过get(Object key)查找curValue值
- 然后判断这个curValue值与传入的value是否相等,不相等就直接返回。
- 相等的话，就判断key值在集合中是否存在。
