Map接口大全解

小灰灰 2022-01-29 00:21 253阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1OTMzMjQ5_size_16_color_FFFFFF_t_70][]

/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
 
 package java.util;
 
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.io.Serializable;
 
 /**
 * Map是把key映射到value的对象. 一个map不能包含重复的key;
 * 每个key最多只能映射一个value.
 *
 * Map接口完全地取代了Dictionary类，Dictionary是抽象类而不是接口.
 *
 * Map接口提供了三个集合视图, 允许map内容被作为keys、values、keys-values集合
 * map的元素的顺序为迭代器返回元素的顺序
 * map的一些实现类像TreeMap保证具体的元素顺序，但是像hashMap却没有定义顺序
 * 注意：如果使用可变对象最为map的keys一定要非常小心。
 * 当map中的key是object,key的值value通过改变equals()比较，那么map的行为是不可指定的
 * 这个禁令的特例是map不可以将自己作为key,尽管map可以将自己作为为value,但建议要非常小心，因为
 * equals()和hashCode（）在map中不在被定义
 *
 * 所有通用map的实现类应该提供两个标准的构造方法，一个是用来创建空map无参构造函数,一个是提供一个Map类型的参数来创建
 * 具有相同keys-values的map来作为参数，事实上，后者构造方法可以让用户复制一切map，产生所需要的等效map.
 * 没有办法强制推荐，因为接口不包含构造方法，但是在JDK中所有的通用map都实现了。
 *
 * 在Map接口中包含“破环性”的方法，他们的方法会修改map,如果map不支持此类操作将会抛出UnsupportedOperationException、
 * 如果调用对map没有影响这种情况，可能会抛出UnsupportedOperationException。例如：
 * 如果map映射叠加为空，调用putAll(Map)并未修改map，这种不是必须抛出异常
 *
 * 一些map实现对它们的key-value是有限制的，例如一些map禁止key,value为null,有些对它们的key也会有限制
 * ，当尝试插入不合格的key-value是就会抛出未检查的异常，特别是NullPointerException或者ClassCastException
 * 尝试查询现有不合格key-value可能抛出一个异常或者返回false,一些实现会表现为类似前者的行为，也有一些会表现为
 * 后者。更通常是的，尝试对不合格的key,value进行操作，其结果不会让不合格的key,value插入到map中导致抛出异常或执行
 * 成功，此异常在此规范中被标记为可选
 *
 * 在Collections Framework interfaces 中许多方法都是根据equals()方法定义的，
 * 例如：containsKey(Object):如果仅是map中包含一个key返回true
 
 *
 * @param <K> the type of keys maintained by this map
 * @param <V> the type of mapped values
 *
 * @author Josh Bloch
 * @see HashMap
 * @see TreeMap
 * @see Hashtable
 * @see SortedMap
 * @see Collection
 * @see Set
 * @since 1.2
 */
 public interface Map<K,V> {
 // Query Operations
 
 /**
 * 返回此map中键值映射的数量。 如果map包含超过Integer.MAX_VALUE个元素，则返回Integer.MAX_VALUE 。
 *
 */
 int size();
 
 /**
 * 如果此map不包含键值映射，则返回 true
 *
 */
 boolean isEmpty();
 
 /**
 *如果此映射包含指定键的映射
 */
 boolean containsKey(Object key);
 
 /**
 *如果此映射将一个或多个键映射到指定的值，则返回true
 */
 boolean containsValue(Object value);
 
 
 V get(Object key);
 
 // Modification Operations
 
 /**
 */
 V put(K key, V value);
 
 
 V remove(Object key);
 
 
 // Bulk Operations
 
 /**
 */
 void putAll(Map<? extends K, ? extends V> m);
 
 
 void clear();
 
 
 // Views
 
 /**
 * 返回map中的keys的Set视图,由map所支持，所以对map的改变会反应在set集合中，
 * 反之亦然，如果map在迭代中被修改（除了iterator的remove）,迭代结果是未定义
 * 的，该集合支持从相应的map中移除，通过Iterator.remove，Set.remove
 * removeAll，retainAll、clear
 */
 Set<K> keySet();
 
 //返回值集合
 Collection<V> values();
 
 
 Set<Map.Entry<K, V>> entrySet();
 
 /**
 * key-value接口，Map.entrySet返回map的Entry<K,V>的集合元素，获得此引用的唯一途径是
 * 集合试图的迭代器，这些Map.Entry在迭代期间才是有效的，更正式是，在entry迭代返回后
 * 如果map已经被修改了，那么a map entry的行为是未定义的
 *
 * @see Map#entrySet()
 * @since 1.2
 */
 interface Entry<K,V> {
 
 K getKey();
 
 
 
 V getValue();
 
 /**
 * Replaces the value corresponding to this entry with the specified
 * value (optional operation). (Writes through to the map.) The
 * behavior of this call is undefined if the mapping has already been
 * removed from the map (by the iterator's <tt>remove</tt> operation).
 *
 * @param value new value to be stored in this entry
 * @return old value corresponding to the entry
 * @throws UnsupportedOperationException if the <tt>put</tt> operation
 * is not supported by the backing map
 * @throws ClassCastException if the class of the specified value
 * prevents it from being stored in the backing map
 * @throws NullPointerException if the backing map does not permit
 * null values, and the specified value is null
 * @throws IllegalArgumentException if some property of this value
 * prevents it from being stored in the backing map
 * @throws IllegalStateException implementations may, but are not
 * required to, throw this exception if the entry has been
 * removed from the backing map.
 */
 V setValue(V value);
 
 /**
 * Compares the specified object with this entry for equality.
 * Returns <tt>true</tt> if the given object is also a map entry and
 * the two entries represent the same mapping. More formally, two
 * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
 * if<pre>
 * (e1.getKey()==null ?
 * e2.getKey()==null : e1.getKey().equals(e2.getKey())) &&
 * (e1.getValue()==null ?
 * e2.getValue()==null : e1.getValue().equals(e2.getValue()))
 * </pre>
 * This ensures that the <tt>equals</tt> method works properly across
 * different implementations of the <tt>Map.Entry</tt> interface.
 *
 * @param o object to be compared for equality with this map entry
 * @return <tt>true</tt> if the specified object is equal to this map
 * entry
 */
 boolean equals(Object o);
 
 /**
 * Returns the hash code value for this map entry. The hash code
 * of a map entry <tt>e</tt> is defined to be: <pre>
 * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
 * (e.getValue()==null ? 0 : e.getValue().hashCode())
 * </pre>
 * This ensures that <tt>e1.equals(e2)</tt> implies that
 * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
 * <tt>e1</tt> and <tt>e2</tt>, as required by the general
 * contract of <tt>Object.hashCode</tt>.
 *
 * @return the hash code value for this map entry
 * @see Object#hashCode()
 * @see Object#equals(Object)
 * @see #equals(Object)
 */
 int hashCode();
 
 /**
 * Returns a comparator that compares {@link Map.Entry} in natural order on key.
 *
 * The returned comparator is serializable and throws {@link
 * NullPointerException} when comparing an entry with a null key.
 *
 * @param <K> the {@link Comparable} type of then map keys
 * @param <V> the type of the map values
 * @return a comparator that compares {@link Map.Entry} in natural order on key.
 * @see Comparable
 * @since 1.8
 */
 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());
 }
 
 /**
 * Returns a comparator that compares {@link Map.Entry} in natural order on value.
 *
 * The returned comparator is serializable and throws {@link
 * NullPointerException} when comparing an entry with null values.
 *
 * @param <K> the type of the map keys
 * @param <V> the {@link Comparable} type of the map values
 * @return a comparator that compares {@link Map.Entry} in natural order on value.
 * @see Comparable
 * @since 1.8
 */
 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());
 }
 
 /**
 * Returns a comparator that compares {@link Map.Entry} by key using the given
 * {@link Comparator}.
 *
 * The returned comparator is serializable if the specified comparator
 * is also serializable.
 *
 * @param <K> the type of the map keys
 * @param <V> the type of the map values
 * @param cmp the key {@link Comparator}
 * @return a comparator that compares {@link Map.Entry} by the key.
 * @since 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());
 }
 
 /**
 * Returns a comparator that compares {@link Map.Entry} by value using the given
 * {@link Comparator}.
 *
 * The returned comparator is serializable if the specified comparator
 * is also serializable.
 *
 * @param <K> the type of the map keys
 * @param <V> the type of the map values
 * @param cmp the value {@link Comparator}
 * @return a comparator that compares {@link Map.Entry} by the value.
 * @since 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
 
 
 boolean equals(Object o);
 
 
 
 int hashCode();
 
 // Defaultable methods
 
 /**
 * 返回指定key的映射，如果不包含map的key则返回defaultValue
 */
 default V getOrDefault(Object key, V defaultValue) {
 V v;
 return (((v = get(key)) != null) || containsKey(key))
 ? v
 : defaultValue;
 }
 
 /**
 * 对此映射中的每个entry执行操作，直到条目全部被处理或者抛出异常
 * 除非实现类另有指定，否则按照进入设置迭代的顺序执行操作（如果指定了迭代顺序）。操作引发的异常被转发给调用者。
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 * <pre> {@code
 * for (Map.Entry<K, V> entry : map.entrySet())
 * action.accept(entry.getKey(), entry.getValue());
 * }</pre>
 *默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
 *
 * @param action The action to be performed for each entry
 * @throws NullPointerException if the specified action is null
 * @throws ConcurrentModificationException if an entry is found to be
 * removed during iteration
 * @since 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);
 }
 }
 
 /**
 * 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。 函数抛出的异常被转发给调用者。
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 * <pre> {@code
 * for (Map.Entry<K, V> entry : map.entrySet())
 * entry.setValue(function.apply(entry.getKey(), entry.getValue()));
 * }</pre>
 *默认实现不会保证此方法的同步或原子属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
 *
 * @param function the function to apply to each entry
 * @throws UnsupportedOperationException if the {@code set} operation
 * is not supported by this map's entry set iterator.
 * @throws ClassCastException if the class of a replacement value
 * prevents it from being stored in this map
 * @throws NullPointerException if the specified function is null, or the
 * specified replacement value is null, and this map does not permit null
 * values
 * @throws ClassCastException if a replacement value is of an inappropriate
 * type for this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if function or a replacement value is null,
 * and this map does not permit null keys or values
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of a replacement value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ConcurrentModificationException if an entry is found to be
 * removed during iteration
 * @since 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);
 }
 }
 }
 
 /**
 * If the specified key is not already associated with a value (or is mapped
 * to {@code null}) associates it with the given value and returns
 * {@code null}, else returns the current value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code
 * map}:
 *
 * <pre> {@code
 * V v = map.get(key);
 * if (v == null)
 * v = map.put(key, value);
 *
 * return v;
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with the specified key, or
 * {@code null} if there was no mapping for the key.
 * (A {@code null} return can also indicate that the map
 * previously associated {@code null} with the key,
 * if the implementation supports null values.)
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the key or value is of an inappropriate
 * type for this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 * and this map does not permit null keys or values
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of the specified key
 * or value prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
 default V putIfAbsent(K key, V value) {
 V v = get(key);
 if (v == null) {
 v = put(key, value);
 }
 
 return v;
 }
 
 /**
 * Removes the entry for the specified key only if it is currently
 * mapped to the specified value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
 * map.remove(key);
 * return true;
 * } else
 * return false;
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is associated
 * @param value value expected to be associated with the specified key
 * @return {@code true} if the value was removed
 * @throws UnsupportedOperationException if the {@code remove} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the key or value is of an inappropriate
 * type for this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 * and this map does not permit null keys or values
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 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;
 }
 
 /**
 * Replaces the entry for the specified key only if currently
 * mapped to the specified value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
 * map.put(key, newValue);
 * return true;
 * } else
 * return false;
 * }</pre>
 *
 * The default implementation does not throw NullPointerException
 * for maps that do not support null values if oldValue is null unless
 * newValue is also null.
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is associated
 * @param oldValue value expected to be associated with the specified key
 * @param newValue value to be associated with the specified key
 * @return {@code true} if the value was replaced
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of a specified key or value
 * prevents it from being stored in this map
 * @throws NullPointerException if a specified key or newValue is null,
 * and this map does not permit null keys or values
 * @throws NullPointerException if oldValue is null and this map does not
 * permit null values
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws IllegalArgumentException if some property of a specified key
 * or value prevents it from being stored in this map
 * @since 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;
 }
 
 /**
 * Replaces the entry for the specified key only if it is
 * currently mapped to some value.
 *
 * @implSpec
 * The default implementation is equivalent to, for this {@code map}:
 *
 * <pre> {@code
 * if (map.containsKey(key)) {
 * return map.put(key, value);
 * } else
 * return null;
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties.
 *
 * @param key key with which the specified value is associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with the specified key, or
 * {@code null} if there was no mapping for the key.
 * (A {@code null} return can also indicate that the map
 * previously associated {@code null} with the key,
 * if the implementation supports null values.)
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key or value is null,
 * and this map does not permit null keys or values
 * @throws IllegalArgumentException if some property of the specified key
 * or value prevents it from being stored in this map
 * @since 1.8
 */
 default V replace(K key, V value) {
 V curValue;
 if (((curValue = get(key)) != null) || containsKey(key)) {
 curValue = put(key, value);
 }
 return curValue;
 }
 
 /**
 * If the specified key is not already associated with a value (or is mapped
 * to {@code null}), attempts to compute its value using the given mapping
 * function and enters it into this map unless {@code null}.
 *
 * If the function returns {@code null} no mapping is recorded. If
 * the function itself throws an (unchecked) exception, the
 * exception is rethrown, and no mapping is recorded. The most
 * common usage is to construct a new object serving as an initial
 * mapped value or memoized result, as in:
 *
 * <pre> {@code
 * map.computeIfAbsent(key, k -> new Value(f(k)));
 * }</pre>
 *
 * Or to implement a multi-value map, {@code Map<K,Collection<V>>},
 * supporting multiple values per key:
 *
 * <pre> {@code
 * map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
 * }</pre>
 *
 *
 * @implSpec
 * The default implementation is equivalent to the following steps for this
 * {@code map}, then returning the current value or {@code null} if now
 * absent:
 *
 * <pre> {@code
 * if (map.get(key) == null) {
 * V newValue = mappingFunction.apply(key);
 * if (newValue != null)
 * map.put(key, newValue);
 * }
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param mappingFunction the function to compute a value
 * @return the current (existing or computed) value associated with
 * the specified key, or null if the computed value is null
 * @throws NullPointerException if the specified key is null and
 * this map does not support null keys, or the mappingFunction
 * is null
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 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;
 }
 
 /**
 * If the value for the specified key is present and non-null, attempts to
 * compute a new mapping given the key and its current mapped value.
 *
 * If the function returns {@code null}, the mapping is removed. If the
 * function itself throws an (unchecked) exception, the exception is
 * rethrown, and the current mapping is left unchanged.
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if now absent:
 *
 * <pre> {@code
 * 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);
 * }
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param remappingFunction the function to compute a value
 * @return the new value associated with the specified key, or null if none
 * @throws NullPointerException if the specified key is null and
 * this map does not support null keys, or the
 * remappingFunction is null
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 1.8
 */
 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;
 }
 }
 
 /**
 * Attempts to compute a mapping for the specified key and its current
 * mapped value (or {@code null} if there is no current mapping). For
 * example, to either create or append a {@code String} msg to a value
 * mapping:
 *
 * <pre> {@code
 * map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))}</pre>
 * (Method {@link #merge merge()} is often simpler to use for such purposes.)
 *
 * If the function returns {@code null}, the mapping is removed (or
 * remains absent if initially absent). If the function itself throws an
 * (unchecked) exception, the exception is rethrown, and the current mapping
 * is left unchanged.
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if absent:
 *
 * <pre> {@code
 * 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;
 * }
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the specified value is to be associated
 * @param remappingFunction the function to compute a value
 * @return the new value associated with the specified key, or null if none
 * @throws NullPointerException if the specified key is null and
 * this map does not support null keys, or the
 * remappingFunction is null
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @since 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;
 }
 }
 
 /**
 * If the specified key is not already associated with a value or is
 * associated with null, associates it with the given non-null value.
 * Otherwise, replaces the associated value with the results of the given
 * remapping function, or removes if the result is {@code null}. This
 * method may be of use when combining multiple mapped values for a key.
 * For example, to either create or append a {@code String msg} to a
 * value mapping:
 *
 * <pre> {@code
 * map.merge(key, msg, String::concat)
 * }</pre>
 *
 * If the function returns {@code null} the mapping is removed. If the
 * function itself throws an (unchecked) exception, the exception is
 * rethrown, and the current mapping is left unchanged.
 *
 * @implSpec
 * The default implementation is equivalent to performing the following
 * steps for this {@code map}, then returning the current value or
 * {@code null} if absent:
 *
 * <pre> {@code
 * 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);
 * }</pre>
 *
 * The default implementation makes no guarantees about synchronization
 * or atomicity properties of this method. Any implementation providing
 * atomicity guarantees must override this method and document its
 * concurrency properties. In particular, all implementations of
 * subinterface {@link java.util.concurrent.ConcurrentMap} must document
 * whether the function is applied once atomically only if the value is not
 * present.
 *
 * @param key key with which the resulting value is to be associated
 * @param value the non-null value to be merged with the existing value
 * associated with the key or, if no existing value or a null value
 * is associated with the key, to be associated with the key
 * @param remappingFunction the function to recompute a value if present
 * @return the new value associated with the specified key, or null if no
 * value is associated with the key
 * @throws UnsupportedOperationException if the {@code put} operation
 * is not supported by this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws ClassCastException if the class of the specified key or value
 * prevents it from being stored in this map
 * (<a href="{@docRoot}/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified key is null and this map
 * does not support null keys or the value or remappingFunction is
 * null
 * @since 1.8
 */
 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;
 }
 }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1OTMzMjQ5_size_16_color_FFFFFF_t_70]: /images/20220129/0f80915d93494cd5a3a1777b241322e0.png