标签：Map return value 键值 接口 key null
Map接口
Map集合是用键值对作为存储元素的集合，所以它可以通过key值来操作集合中的键值对元素。
public interface Map<K,V> {}可以注意到Map接口是一个顶层接口，与Collection没有任何联系，甚至它都没有继承Iterable接口，说明Map是不可迭代的。但是Map集合提供了方法将集合中的元素转换成一个可迭代接口实例。
Map常用方法
1、添加元素
// 向集合中添加 键值对,但是如果key值存在，就替换对应的value值
V put(K key, V value);
// 将集合m中的键值对全部存放到本集合中
void putAll(Map<? extends K, ? extends V> m);2、删除元素
// 根据键key移除Map集合中对应的键值对, 并返回value值
V remove(Object key);
// 清除集合中所有的键值对
void clear();3、替换元素
// 向集合中添加 键值对,但是如果key值存在，就替换对应的value值
V put(K key, V value);4、其他方法
// 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();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();// 工具类方法， 返回一个根据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接口提供默认实现方法
因为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());
}
}
}AbstractMap抽象类
AbstractMap类是Map接口的子类，实现了Map接口大部分方法，它的子类只需要实现Set<Entry<K,V>> entrySet() 返回一个键值对的集合，就可以使用Map集合的功能了。
添加方法
public V put(K key, V value) {
throw new UnsupportedOperationException();
}直接抛出异常，如果子类不复写这个方法，那么它是一个不可修改的Map集合。
public void putAll(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}遍历Map集合m，通过它的entrySet()方法得到可迭代的Set集合，然后将每个键值对存放到本Map集合中。
删除方法
public V remove(Object key) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
Entry<K,V> correctEntry = null;
// 根据key是否为null，分成两部分，虽然这两部分代码逻辑几乎一样
// 这样做主要是减少判断，因为合成一部分的话，判断条件就要增加
if (key==null) {
while (correctEntry==null && i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
correctEntry = e;
}
} else {
while (correctEntry==null && i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
correctEntry = e;
}
}
V oldValue = null;
// 如果找这个键值对correctEntry，删除它，并返回它的value值
if (correctEntry !=null) {
oldValue = correctEntry.getValue();
i.remove();
}
return oldValue;
}通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，删除它，并返回对应的value值，如果没找到，就返回null。
public void clear() {
entrySet().clear();
}调用entrySet集合的clear()方法。
查找元素
public boolean containsKey(Object key) {
// 得到键值对的迭代器
Iterator<Map.Entry<K,V>> i = entrySet().iterator();
// 根据key是否为null，分成两部分
if (key==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
return true;
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
return true;
}
}
return false;
}通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，返回true，否则返回false。
public boolean containsValue(Object value) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
// 根据value是否为null，分成两部分，
if (value==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getValue()==null)
return true;
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (value.equals(e.getValue()))
return true;
}
}
return false;
}通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与value值相等的键值对，返回true，否则返回false。
public V get(Object key) {
// 得到键值对的迭代器
Iterator<Entry<K,V>> i = entrySet().iterator();
// 根据key是否为null，分成两部分，
if (key==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
return e.getValue();
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
return e.getValue();
}
}
return null;
}通过entrySet().iterator()方法，得到键值对的迭代器，然后遍历键值对，找到与key值相等的键值对，并返回对应的value值，如果没找到，就返回null。
遍历Map集合
我们知道Map接口可以返回三个集合，分别是key值组成的Set<K>集合，value值组成的Collection<V>集合，以及键值对组成的Set<Map.Entry<K, V>>集合。
其实这里面最重要的是键值对组成的Set集合，因为其他两个集合可以通过这个集合得到。
public Set<K> keySet() {
// 使用keySet变量做缓存用的，这样只有第一次时需要遍历entrySet()集合。
Set<K> ks = keySet;
if (ks == null) {
// 创建一个Set集合，对它的操作都调用Map集合对应方法。
ks = new AbstractSet<K>() {
public Iterator<K> iterator() {
// 创建一个迭代器，利用 entrySet().iterator()的迭代器来实现本Iterator实例的方法。
return new Iterator<K>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public K next() {
return i.next().getKey();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object k) {
return AbstractMap.this.containsKey(k);
}
};
keySet = ks;
}
return ks;
}public Collection<V> values() {
// 使用values变量做缓存用的，防止每次都遍历创建
Collection<V> vals = values;
if (vals == null) {
// 创建一个Collection集合，对它的操作都调用Map集合对应方法。
vals = new AbstractCollection<V>() {
public Iterator<V> iterator() {
// 创建一个迭代器，利用 entrySet().iterator()的迭代器来实现本Iterator实例的方法。
return new Iterator<V>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public V next() {
return i.next().getValue();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object v) {
return AbstractMap.this.containsValue(v);
}
};
values = vals;
}
return vals;
}AbstractMap的内部类 SimpleEntry
SimpleEntry实现了Map.Entry接口，表示一个简单地键值对类。它有两个成员属性key、value来存储键值对。
public static class SimpleEntry<K,V>
implements Entry<K,V>, java.io.Serializable
{
private static final long serialVersionUID = -8499721149061103585L;
private final K key;
private V value;
// 构造函数时，就传入key值和value值
public SimpleEntry(K key, V value) {
this.key = key;
this.value = value;
}
// 或者使用另一个entry来初始化key值和value值
public SimpleEntry(Entry<? extends K, ? extends V> entry) {
this.key = entry.getKey();
this.value = entry.getValue();
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
// 替换value值，并返回原来的oldValue值
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
// 当key值与value值都相等时，就说明两个entry值相等
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return eq(key, e.getKey()) && eq(value, e.getValue());
}
// 保证两个相等的entry，它们的hashCode值必须也相同
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
public String toString() {
return key + "=" + value;
}
}AbstractMap的内部类 SimpleImmutableEntry
SimpleImmutableEntry表示一个不可修改键值对Entry类，也就是说它的setValue(V value)方法会直接抛出异常，其他方法与SimpleEntry类一样。
public static class SimpleImmutableEntry<K,V>
implements Entry<K,V>, java.io.Serializable
{
private static final long serialVersionUID = 7138329143949025153L;
private final K key;
private final V value;
// 构造函数时，就传入key值和value值
public SimpleImmutableEntry(K key, V value) {
this.key = key;
this.value = value;
}
// 当key值与value值都相等时，就说明两个entry值相等
public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
this.key = entry.getKey();
this.value = entry.getValue();
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
// 因为是不可修改键值对Entry类，所以setValue方法直接抛出异常
public V setValue(V value) {
throw new UnsupportedOperationException();
}
// 当key值与value值都相等时，就说明两个entry值相等
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return eq(key, e.getKey()) && eq(value, e.getValue());
}
// 保证两个相等的entry，它们的hashCode值必须也相同
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
public String toString() {
return key + "=" + value;
}
}
标签：Map,return,value,键值,接口,key,null 来源： https://www.cnblogs.com/xfeiyun/p/15867361.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。