map
* public interface Map<K,V>
将键映射到值的对象。 地图不能包含重复的键; 每个键可以映射到最多一个值。
这个接口取代了Dictionary类，它是一个完全抽象的类而不是接口。
Map界面提供了三个集合视图 ，允许将映射内容视为一组键，值集合或键值映射集合。 地图的顺序被定义为其中在地图上的集合视图迭代返回元素的顺序。 一些地图实现，如TreeMap课程，对他们的订单做出了具体的保证; 其他人，像HashMap班，不要。
注意：如果使用可变对象作为地图键，必须非常小心。 如果对象的值以影响equals比较的方式更改，而对象是地图中的键，则不会指定地图的行为。 这个禁令的一个特殊情况是，地图不允许将自己包含在内。 虽然地图可以将其本身作为一个值，但建议您非常小心： equals和hashCode方法在这样的地图上已经不太明确。
所有通用映射实现类应提供两个“标准”构造函数：一个创建空映射的void（无参数）构造函数，以及一个具有类型为Map的单个参数的构造函数 ，它创建一个具有相同键值的新映射映射作为参数。 实际上，后一个构造函数允许用户复制任何地图，产生所需类的等效地图。 没有办法强制执行此建议（因为接口不能包含构造函数），而JDK中的所有通用映射实现都符合要求。
包含在该界面中的“破坏性”的方法，即，修改其操作地图的方法，被指定抛出UnsupportedOperationException如果此映射不支持该操作。 如果是这种情况，如果调用对地图没有影响，这些方法可能会但不是必须抛出UnsupportedOperationException 。 例如，如果映射映射为“叠加”的地图为空，则可以在不可修改的映射上调用putAll(Map)方法，但不是必须抛出异常。
一些地图实现对它们可能包含的键和值有限制。 例如，一些实现禁止空键和值，有些对键的类型有限制。 尝试插入不合格的键或值会抛出未经检查的异常，通常为NullPointerException或ClassCastException 。 尝试查询不合格键或值的存在可能会引发异常，或者可能只是返回false; 一些实现将展现出前者的行为，一些实现将展现出后者。 更一般来说，尝试对不符合条件的密钥或值的操作，其完成不会导致将不合格元素插入到地图中可能会导致异常或可能成功执行该选项。 此异常在此接口的规范中标记为“可选”。
Collections Framework接口中的许多方法都是按照equals方法定义的。 例如，对于在本说明书containsKey(Object key)方法表示：“返回true当且仅当此映射包含一个键k使得(key==null ? k==null : key.equals(k))的映射。” 该规范不应该被解释为意味着具有非空参数调用key Map.containsKey会导致key.equals(k)被调用的任意键k。 实现可以实现优化，从而避免equals的调用，例如，首先比较两个密钥的哈希码。 （ Object.hashCode()规范保证具有不等的哈希码的两个对象不能相等。）更一般地，各种Collections Framework接口的实现可以随意使用底层Object方法的指定行为，无论执行者认为适当。
执行递归遍历地图的一些地图操作可能会失败，并且地图直接或间接包含自身的自引用实例有异常。 这包括clone() ， equals() ， hashCode()和toString()方法。 实现可以可选地处理自引用场景，然而大多数当前实现不这样做。
此接口是成员Java Collections Framework 。
public interface Map<K,V> {
// Query Operations
/**
* 返回此map中键值映射的数量。 如果地图包含超过Integer.MAX_VALUE个元素，则返回Integer.MAX_VALUE 。
结果
该地图中键值映射的数量
*/
int size();
/**
* 如果此地图不包含键值映射，则返回 true 。
结果
true如果此映射不包含键值映射
*/
boolean isEmpty();
/**
* 如果此映射包含指定键的映射，则返回true 。 更正式地，返回true当且仅当该地图包含关键字k的映射，使得(key==null ? k==null : key.equals(k)) 。 （最多可以有一个 这样的映射。）
参数
key - 要在此地图中存在的密钥要进行测试
结果
true如果此映射包含指定键的映射
异常
ClassCastException - 如果密钥对于该地图是不合适的类型（ optional ）
NullPointerException - 如果指定的键为空，并且此映射不允许空键（ optional ）
*/
boolean containsKey(Object key);
/**
* 如果此映射将一个或多个键映射到指定的值，则返回true 。 更正式地，返回true当且仅当此映射包含至少一个映射到值v ，使得(value==null ? v==null : value.equals(v)) 。 对于Map接口的大多数实现，此操作对于地图大小可能需要时间线性。
参数
value - 要在此地图中存在的值要进行测试
结果
true如果该地图将一个或多个键映射到指定的值
异常
ClassCastException - 如果该值对于该地图是不合适的类型（ optional ）
NullPointerException - 如果指定的值为空，并且此映射不允许空值（ optional ）
*/
boolean containsValue(Object value);
/**
* 返回到指定键所映射的值，或null如果此映射包含该键的映射。
更正式地，如果该映射包含从键k到值v ，使得(key==null ? k==null : key.equals(k)) ，则该方法返回v ; 否则返回null 。 （最多可以有一个这样的映射。）
如果此映射允许空值，则返回值null并不一定表明该映射不包含该键的映射关系; Map也可能明确地将密钥映射到null 。 可以使用containsKey操作来区分这两种情况。
参数
key - 要返回其关联值的键
结果
指定键映射到的值，如果此映射不包含键的映射， null
异常
ClassCastException - 如果密钥是该地图不合适的类型（ optional ）
NullPointerException - 如果指定的键为空，并且此映射不允许空键（ optional ）
*/
V get(Object key);
// Modification Operations
/**
* V put(K key,
V value)
将指定的值与该映射中的指定键相关联（可选操作）。 如果映射先前包含了密钥的映射，则旧值将被指定的值替换。 （映射m被认为包含关键字的映射k当且仅当m.containsKey(k)将返 回 true ）。
参数
key - 指定值与之关联的键
value - 与指定键相关联的值
结果
前一个值与key相关联 ，或null，如果没有key的映射。 （A null返回也可以表示该地图以前关联的null与key ，如果实现支持null的值）
异常
UnsupportedOperationException -如果 put操作不受此地图支持
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中
NullPointerException - 如果指定的键或值为空，并且此映射不允许空值或值
IllegalArgumentException - 如果指定键或值的某些属性阻止其存储在此映射中
*/
V put(K key, V value);
/**
* 如果存在（从可选的操作），从该地图中删除一个键的映射。 更正式地，如果该映射包含从关键字k到值v的映射，使得(key==null ? k==null : key.equals(k)) ，该映射被去 除。 （地图最多可以包含一个这样的映射。）
返回此地图先前相关联的密钥，或null如果映射包含该键的映射值。
如果此映射允许空值，那么null返回值并不一定表明此映射不包含该键的映射关系; 地图也可能显式地将密钥映射到null 。
一旦呼叫返回，该映射将不包含指定键的映射。
参数
key - 其映射将从地图中删除的密钥
结果
前一个值与 key相关联 ，或 null，如果没有 key的映射。
异常
UnsupportedOperationException -如果 remove操作不受此地图支持
ClassCastException - 如果密钥对于此地图是不合适的类型（ optional ）
NullPointerException - 如果指定的键为空，并且此映射不允许空键（ optional ）
*/
V remove(Object key);
// Bulk Operations
/**
* void putAll(Map<? extends K,? extends V> m)
将指定地图的所有映射复制到此映射（可选操作）。 该呼叫的效果与从指定地图中的关键字k到值v的每个映射一次对该地图一次调用put(k, v)的效果相当。 如果在操作进行中修改了指 定的地图，则此操作的行为是未定义的。
参数
m - 要存储在此地图中的映射
异常
UnsupportedOperationException -如果 putAll操作不受此地图支持
ClassCastException - 如果指定地图中的键或值的类阻止它存储在此映射中
NullPointerException - 如果指定的地图为空，或者该地图不允许空值或值，并且指定的地图包含空值或值
IllegalArgumentException - 如果指定地图中的键或值的某些属性阻止其存储在此映射中
*/
void putAll(Map<? extends K, ? extends V> m);
/**
* 从该地图中删除所有的映射（可选操作）。 此呼叫返回后，地图将为空。
异常
UnsupportedOperationException -如果 clear操作不受此地图支持
*/
void clear();
// Views
* 返回此地图中包含的键的Set视图。 该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的remove 操作），迭代的结果是未定义的。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove，Set.remove，removeAll，retainAll和clear操作。 它不支持add或addAll操 作。
结果
该地图中包含的键的集合视图
*/
Set<K> keySet();
/**
* 返回此地图中包含的值的Collection视图。 集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的 remove操作），迭代的结果是未定义的。 该collection支持元素移除，即从映射中相应的映射，经由Iterator.remove，Collection.remove，removeAll，retainAll和clear操作。 它不支持add或addAll操作。
结果
该地图中包含的值的集合视图
*/
Collection<V> values();
/**
* 返回此地图中包含的映射的Set视图。 该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 如果在集合中的迭代正在进行时修改映射（除了通过迭代器自己的 remove操作，或者通过迭代器返回的映射条目上的setValue操作），迭代的结果是未定义的。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove，Set.remove， removeAll，retainAll和clear操作。 它不支持add或addAll操作。
结果
该地图中包含的映射的集合视图
*/
Set<Map.Entry<K, V>> entrySet();
/**
* 地图条目（键值对）。 Map.entrySet方法返回地图的集合视图，其元素属于此类。 获取对映射条目的引用的唯一方法是从该集合视图的迭代器。 这些Map.Entry对象仅在迭代期间有 效; 更正式地，如果在迭代器返回条目之后已经修改了背景映射，则映射条目的行为是未定义的，除非通过映射条目上的setValue操作。
*/
interface Entry<K,V> {
*
返回与此条目相对应的键。
结果
与此条目相对应的键
异常
IllegalStateException - 如果条目已从后备映射中删除，则实现可能但不是必须抛出此异常。
*/
K getKey();
* 返回与此条目相对应的值。 如果映射已从背景映射中删除（通过迭代器的remove操作），则此调用的结果未定义。
结果
与此条目对应的值
异常
IllegalStateException - 如果条目已从背景地图中删除，则实现可能但不是必须抛出此异常。
*/
V getValue();
/**
* 用指定的值替换与该条目相对应的值（可选操作）。 （写入地图。）如果映射已经从映射中移除（由迭代器的remove操作），则此调用的行为是未定义的。
参数
value - 要存储在此条目中的新值
结果
旧值对应的条目
异常
UnsupportedOperationException -如果 put操作不受底层映射支持
ClassCastException - 如果指定值的类阻止它存储在后台映射中
NullPointerException - 如果后台映射不允许空值，并且指定的值为空
IllegalArgumentException - 如果此值的某些属性阻止其存储在后备映射中
IllegalStateException - 如果条目已从后备映射中删除，则实现可能但不是必须抛出此异常。
*/
V setValue(V value);
/**
* 将指定的对象与此条目进行比较以获得相等性。 如果给定对象也是映射条目，则返回true ，并且两个条目表示相同的映射。 更正式地，两个条目e1和e2表示相同的映射
(e1.getKey()==null ?
e2.getKey()==null : e1.getKey().equals(e2.getKey())) &&
(e1.getValue()==null ?
e2.getValue()==null : e1.getValue().equals(e2.getValue()))
这确保equals方法在Map.Entry接口的不同实现中正常工作。
重写：
equals在类别 Object
参数
o - 要与该地图条目相等的对象
结果
true如果指定的对象等于此映射条目
另请参见：
Object.hashCode() ， HashMap
*/
boolean equals(Object o);
/**
* 返回此映射条目的哈希码值。 映射条目e的哈希码被定义为：
(e.getKey()==null ? 0 : e.getKey().hashCode()) ^
(e.getValue()==null ? 0 : e.getValue().hashCode())
这确保了e1.equals(e2)意味着e1.hashCode()==e2.hashCode()对于任何两个条目e1和e2，如要求的Object.hashCode总承包合同。
重写：
hashCode在类别 Object
结果
该地图条目的哈希码值
另请参见：
Object.hashCode() ， Object.equals(Object) ， equals(Object)
*/
int hashCode();
/**
* static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>> comparingByKey()
返回一个比较器 ，按键自然顺序比较Map.Entry 。
返回的比较器是可序列化的，当将条目与空键进行比较时，它将抛出NullPointerException 。
参数类型
K - 那个地图键的Comparable类型
V - 地图值的类型
结果
一个比较，比较Map.Entry在自然顺序的关键。
从以下版本开始：
1.8
另请参见：
Comparable
*/
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());
}
/**
* static <K,V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue()
返回一个比较值，比较Map.Entry的自然顺序值。
返回的比较器是可序列化，并引发NullPointerException比较空值的条目时。
参数类型
K - 地图键的类型
V - Comparable类型的地图值
结果
一个比较值比较Map.Entry的自然顺序。
从以下版本开始：
1.8
另请参见：
Comparable
*/
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());
}
/**
* static <K,V> Comparator<Map.Entry<K,V>> comparingByKey(Comparator<? super K> cmp)
返回一个比较器，比较Map.Entry按键使用给定的Comparator 。
如果指定的比较器也可串行化，则返回的比较器是可序列化的。
参数类型
K - 地图键的类型
V - 地图值的类型
参数
cmp - 关键Comparator
结果
一个比较器，比较Map.Entry的关键。
从以下版本开始：
1.8
*/
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());
}
/**
* 返回一个比较器 ，使用给定的Comparator比较Map.Entry的值。
如果指定的比较器也可串行化，则返回的比较器是可序列化的。
参数类型
K - 地图键的类型
V - 地图值的类型
参数
cmp - 值Comparator
结果
一个比较器比较Map.Entry的值。
从以下版本开始：
1.8
*/
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());
}
}
// Comparison and hashing
/**
* 将指定的对象与此映射进行比较以获得相等性。 如果给定的对象也是一个地图，并且两个地图代表相同的映射，则返回true 。 更正式地，如果 m1.entrySet().equals(m2.entrySet()) ，两个地图m1和m2代表相同的映射。 这确保equals方法在Map接口的不同实现方面正常工作。
重写：
equals在类别 Object
参数
o - 要与此映射相等的对象进行比较
结果
true如果指定的对象等于此映射
另请参见：
Object.hashCode() ， HashMap
*/
boolean equals(Object o);
/**
* 返回此地图的哈希码值。 map的哈希码被定义为地图entrySet()视图中每个条目的哈希代码的总和。 这确保m1.equals(m2)意味着m1.hashCode()==m2.hashCode()对于任何两 个地图m1和m2 ，根据Object.hashCode()的一般合同的要求 。
重写：
hashCode在类别 Object
结果
该地图的哈希码值
*/
int hashCode();
// Defaultable methods
/**
* 返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。
实现要求：
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
key - 要返回其关联值的键
defaultValue - 键的默认映射
结果
指定键映射到的值，如果此映射不包含该键的映射， defaultValue
异常
ClassCastException - 如果密钥是该地图的不当类型（ optional ）
NullPointerException - 如果指定的键为空，并且此映射不允许空键（ optional ）
简单的说就是根据key匹配，在key存在时，就使用key对应value值，如果不存在，则使用第二个参数的值
从以下版本开始：
*/
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
/**
*
对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。 除非实现类另有指定，否则按照进入设置迭代的顺序执行操作（如果指定了迭代顺序）。操作引发的 异常被转发给调用者。
实现要求：
默认实现相当于，对于这个map ：
for (Map.Entry<K, V> entry : map.entrySet()) action.accept(entry.getKey(), entry.getValue());
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
action - 要为每个条目执行的操作
异常
NullPointerException - 如果指定的动作为空
ConcurrentModificationException - 如果在迭代期间发现条目被删除
参考增强for循环
从以下版本开始：
1.8
*/
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);
}
}
/**
* default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。 函数抛出的异常被转发给调用者。
实现要求：
默认实现相当于，对于这个map ：
for (Map.Entry<K, V> entry : map.entrySet()) entry.setValue(function.apply(entry.getKey(), entry.getValue()));
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
function - 应用于每个条目的功能
异常
UnsupportedOperationException -如果 set操作不受此映射的条目集迭代器的支持。
ClassCastException - 如果替换值的类阻止它存储在此映射中
NullPointerException - 如果指定的函数为空，或者指定的替换值为空，并且该映射不允许空值
ClassCastException - 如果替换值对于该地图是不合适的类型（ optional ）
NullPointerException - 如果函数或替换值为空，并且此映射不允许空值或值（ optional ）
IllegalArgumentException - 如果替换值的某些属性阻止其存储在此映射中（ optional ）
ConcurrentModificationException - 如果在迭代期间发现条目被删除
过滤字符：
参考 String a = "${condition='通过'}";
String b = a.replaceAll("[${'}]","");
b="condition=通过"
从以下版本开始：
1.8
*/
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);
}
// ise thrown from function is not a cme.
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);
}
}
}
/**
* 如果指定的键尚未与值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。
实现要求：
默认实现相当于，对于这个map ：
V v = map.get(key); if (v == null) v = map.put(key, value); return v;
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
key - 指定值与之关联的键
value - 与指定键相关联的值
结果
与指定键相关联的上一个值，如果没有键的映射， null 。 （A null回报还可以表示该映射以前关联null配钥匙，如果实现支持null值。）
异常
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果该地图的键或值不合适（ optional ）
NullPointerException - 如果指定的键或值为空，并且此映射不允许空值或值（ optional ）
IllegalArgumentException - 如果指定键或值的某些属性阻止其存储在此映射中（ optional ）
当value为null的时候，putIfAbsent()方法会覆盖null值，直到value不为null为止
当value初始值不为null的时候，putIfAbsent()保证返回值始终是唯一的，并且是多线程安全的
putIfAbsent()是有返回值的，应该对他的返回值进行非空判断
2和3主要应用在单例模式中
从以下版本开始：
1.8
*/
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
/** * 仅当指定的密钥当前映射到指定的值时删除该条目。
实现要求：
默认实现相当于，对于这个map ：
if (map.containsKey(key) && Objects.equals(map.get(key), value)) { map.remove(key); return true; } else return false;
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
key - 与指定值相关联的键
value - 预期与指定键相关联的值
结果
true如果该值被删除
异常
UnsupportedOperationException -如果 remove操作不受此地图支持（ optional ）
ClassCastException - 如果该地图的键或值不合适（ optional ）
NullPointerException - 如果指定的键或值为空，并且此映射不允许空键或值（ optional ）
从以下版本开始：
1.8
*/
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
/**
* 仅当当前映射到指定的值时，才能替换指定键的条目。
实现要求：
默认实现相当于，对于这个map ：
if (map.containsKey(key) && Objects.equals(map.get(key), value)) { map.put(key, newValue); return true; } else return false;
如果oldValue为null，则默认实现不会为不支持空值的映射抛出NullPointerException，除非newValue也为空。
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
key - 与指定值相关联的键
oldValue - 预期与指定键相关联的值
newValue - 与指定键相关联的值
结果
true如果该值被替换
异常
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中
NullPointerException - 如果指定的键或newValue为空，并且此映射不允许空值或值
NullPointerException - 如果oldValue为空，并且此映射不允许空值（ optional ）
IllegalArgumentException - 如果指定键或值的某些属性阻止其存储在此映射中
从以下版本开始：
1.8
*/
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;
}
/** * 只有当目标映射到某个值时，才能替换指定键的条目。
实现要求：
默认实现相当于，对于这个map ：
if (map.containsKey(key)) { return map.put(key, value); } else return null;
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
参数
key - 与指定值相关联的键
value - 与指定键相关联的值
结果
与指定键相关联的上一个值，如果没有键的映射， null 。 （A null返回也可以指示映射先前关联的是null的密钥，如果实现支持空值）。
异常
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中（ optional ）
NullPointerException - 如果指定的键或值为空，并且此映射不允许空值或值
IllegalArgumentException - 如果指定键或值的某些属性阻止其存储在此映射中
从以下版本开始：
1.8
*/
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
/** * 如果指定的键尚未与值相关联（或映射到null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非null 。
如果函数返回null则不记录映射。 如果函数本身引发（未检查）异常，则异常被重新引导，并且不记录映射。 最常见的用法是构造一个用作初始映射值或记忆结果的新对象，如：
map.computeIfAbsent(key, k -> new Value(f(k)));
或者实现一个多值地图， Map<K,Collection<V>> ，每个键支持多个值：
map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
实现要求：
默认实现相当于以下步骤为map ，然后返回当前值或null如果现在缺席：
if (map.get(key) == null) { V newValue = mappingFunction.apply(key); if (newValue != null) map.put(key, newValue); }
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录该函数是否仅在 原子上应用，只有当该值不存在时。
参数
key - 指定值与之关联的键
mappingFunction - 计算值的函数
结果
与指定键相关联的当前（现有或计算）值，如果计算值为空，则为null
异常
NullPointerException - 如果指定的键为空，此映射不支持空键，或者mappingFunction为空
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中（ optional ）
String ret;
Map<String, String> map = new HashMap<>();
ret = map.computeIfAbsent("a", key -> key + "123"); //ret "a123", map 为 {"a":"a123"}
ret = map.computeIfAbsent("a", key -> key + "456"); //ret "a123", map 为 {"a":"a123"}
map.put("a", null);
ret = map.computeIfAbsent("a", key -> key + "456"); //ret "a456", map 为 {"a":"a456"}
ret = map.computeIfAbsent("a", key -> null); //ret 为 "a456", map 为 {"a":"a456"}
从以下版本开始：
1.8
*/
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V v;
if ((v = get(key)) == null) {
V newValue;
if ((newValue = mappingFunction.apply(key)) != null) {
put(key, newValue);
return newValue;
}
}
return v;
}
/**
* 如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
如果函数返回null ，则删除映射。 如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
实现要求：
默认实现等效于执行以下步骤执行这一map ，然后返回当前值或null ，如果现在不存在：
if (map.get(key) != null) { V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (newValue != null) map.put(key, newValue); else map.remove(key); }
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录是否只有在该值 不存在时才以原子方式应用该功能。
参数
key - 指定值与之关联的键
remappingFunction - 计算值的函数
结果
与指定键相关的新值，如果没有则为null
异常
NullPointerException - 如果指定的键为空，并且此映射不支持空键，或者remappingFunction为空
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中（ optional ）
map.put("a", "+aaa");
ret = map.computeIfPresent("a", (key, value) -> key + value); //ret "a+aaa", map 为 {"a":"a+aaa"}
ret = map.computeIfPresent("a", (key, value) -> null); //ret 为 null, map 为 {}，计算出的 null 把 key 删除了
计算值
*/
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;
}
}
/**
* 试计算指定密钥及其当前映射值的映射（如果没有当前映射，则null ）。 例如，要为值映射创建或附加一个String msg：
map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
（方法merge()通常更容易用于此类目的。）
如果函数返回null ，则映射将被删除（如果最初缺少，则保持不存在）。 如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
实现要求：
默认实现等效于执行以下步骤执行这一map ，然后返回当前值或null如果缺席：
V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (oldValue != null ) { if (newValue != null) map.put(key, newValue); else map.remove(key); } else { if (newValue != null) map.put(key, newValue); else return null; }
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录该函数是否仅在 原子上被应用，如果该值不存在。
参数
key - 指定值与之关联的键
remappingFunction - 计算值的函数
结果
与指定键相关的新值，如果没有则为null
异常
NullPointerException - 如果指定的键为空，此映射不支持空键，或者remappingFunction为空
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中（ optional ）
eg:统计一个字符串中各个单词出现的频率
public static void main(String[] args) {
HashMap<Character, Integer> result2 = new HashMap<>(32);
for (int i = 0; i < str.length(); i++) {
char curChar = str.charAt(i);
result2.compute(curChar, (k, v) -> {
if (v == null) {
v = 1;
} else {
v += 1;
}
return v;
});
}
}
从以下版本开始：
1.8
*/
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;
}
}
/**
* 如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。 否则，将关联值替换为给定重映射函数的结果，如果结果为null 。 当组合键的多个映射值时，该 方法可能是有用的。 例如，要创建或附加String msg到值映射：
map.merge(key, msg, String::concat)
如果函数返回null ，则删除映射。 如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
实现要求：
默认实现等效于执行以下步骤执行这一map ，然后返回当前值或null如果缺席：
V oldValue = map.get(key); V newValue = (oldValue == null) ? value : remappingFunction.apply(oldValue, value); if (newValue == null) map.remove(key); else map.put(key, newValue);
默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录该函数是否仅在 原子上应用，只有当该值不存在时。
参数
key - 结合值与之关联的键
value - 要与与密钥相关联的现有值合并的非空值，或者如果没有现有值或空值与密钥相关联，则与该密钥相关联
remappingFunction - 重新计算值（如果存在）的功能
结果
与指定键相关联的新值，如果没有值与该键相关联，则返回null
异常
UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
ClassCastException - 如果指定的键或值的类阻止它存储在此映射中（ optional ）
NullPointerException - 如果指定的键为空，并且此映射不支持空键或值或remappingFunction为空
eg:operations.forEach(op ->
balances.merge(op.getAccNo(), op.getAmount(),
(soFar, amount) -> soFar.add(amount))
);
https://www.jianshu.com/p/292f4e346b5d
*/
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;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
