模块  java.base
软件包  java.util

Interface Map<K,​V>

  • 参数类型
    K - 此映射维护的密钥类型
    V - 映射值的类型
    All Known Subinterfaces:
    Bindings ， ConcurrentMap<K,​V> ， ConcurrentNavigableMap<K,​V> ， NavigableMap<K,​V> ， SortedMap<K,​V>
    所有已知实现类：
    AbstractMap ， Attributes ， AuthProvider ， ConcurrentHashMap ， ConcurrentSkipListMap ， EnumMap ， HashMap ， Hashtable ， Headers ， IdentityHashMap ， LinkedHashMap ， PrinterStateReasons ， Properties ， Provider ， RenderingHints ， ScriptObjectMirror ， SimpleBindings ， TabularDataSupport ， TreeMap ， UIDefaults ， WeakHashMap 
    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)) ”。 该规范不应该被解释为意味着调用Map.containsKey与非空参数key会导致key.equals(k)被调用的任意键k 。 实现可以自由地实现优化，从而避免equals调用，例如，首先比较两个密钥的哈希码。 （ Object.hashCode()规范保证具有不等哈希码的两个对象不能相等。）更一般地，各种集合框架接口的实现可以自由地利用底层Object方法的指定行为，只要实现者认为合适。

    执行映射递归遍历的某些映射操作可能会失败，并且映射直接或间接包含自身的自引用实例例外。 这包括clone() ， equals() ， hashCode()和toString()方法。 实现可以可选地处理自引用场景，但是大多数当前实现不这样做。

    Unmodifiable Maps

    该Map.of ， Map.ofEntries和Map.copyOf静态工厂方法提供了一种方便的方法来创建不可修改的地图。 这些方法创建的Map实例具有以下特征：

    • 他们是unmodifiable 。 无法添加，删除或更新密钥和值。 在Map上调用任何mutator方法将始终导致抛出UnsupportedOperationException 。 但是，如果包含的键或值本身是可变的，则可能导致Map的行为不一致或其内容似乎发生变化。
    • 他们不允许null键和值。 尝试使用null键或值创建它们会产生NullPointerException 。
    • 如果所有键和值都是可序列化的，则它们是可序列化的。
    • 他们在创建时拒绝重复密钥。 传递给静态工厂方法的重复键导致IllegalArgumentException 。
    • 映射的迭代顺序未指定，可能会发生变化。
    • 他们是value-based 。 调用者不应对返回实例的身份做出任何假设。 工厂可以自由创建新实例或重用现有实例。 因此，对这些实例的身份敏感操作（引用相等（ == ），身份哈希代码和同步）是不可靠的，应该避免。
    • 它们按照Serialized Form页面上的规定进行序列化。

    此界面是Java Collections Framework的成员。

    从以下版本开始：
    1.2
    另请参见：
    HashMap ， TreeMap ， Hashtable ， SortedMap ， Collection ， Set

    • 嵌套类汇总

      嵌套类  
      变量和类型 接口 描述
      static interface  Map.Entry<K,​V>
      映射条目（键值对）。

    • 方法摘要

      所有方法  静态方法  实例方法 抽象方法  Default Methods 
      变量和类型 方法 描述
      void clear()
      从此映射中删除所有映射（可选操作）。
      default V compute​(K key, BiFunction<? super K,​? super V,​? extends V> remappingFunction)
      尝试计算指定键及其当前映射值的映射（如果没有当前映射， null ）。
      default V computeIfAbsent​(K key, Function<? super K,​? extends V> mappingFunction)
      如果指定的键尚未与值关联（或映射到 null ），则尝试使用给定的映射函数计算其值并将其输入此映射，除非 null 。
      default V computeIfPresent​(K key, BiFunction<? super K,​? super V,​? extends V> remappingFunction)
      如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。
      boolean containsKey​(Object key)
      如果此映射包含指定键的映射，则返回 true 。
      boolean containsValue​(Object value)
      如果此映射将一个或多个键映射到指定值，则返回 true 。
      static <K,​V>
      Map<K,​V>      		 copyOf​(Map<? extends K,​? extends V> map)
      返回包含给定Map的条目的 unmodifiable Map 。
      static <K,​V>
      Map.Entry<K,​V>      		 entry​(K k, V v)
      返回包含给定键和值的不可修改的Map.Entry 。
      Set<Map.Entry<K,​V>> entrySet()
      返回此映射中包含的映射的Set视图。
      boolean equals​(Object o)
      将指定对象与此映射进行比较以获得相等性。
      default void forEach​(BiConsumer<? super K,​? super V> action)
      对此映射中的每个条目执行给定操作，直到处理完所有条目或操作引发异常。
      V get​(Object key)
      返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
      default V getOrDefault​(Object key, V defaultValue)
      返回指定键映射到的值，如果此映射不包含键的映射，则返回 defaultValue 。
      int hashCode()
      返回此映射的哈希码值。
      boolean isEmpty()
      如果此映射不包含键 - 值映射，则返回 true 。
      Set<K> keySet()
      返回此映射中包含的键的Set视图。
      default V merge​(K key, V value, BiFunction<? super V,​? super V,​? extends V> remappingFunction)
      如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。
      static <K,​V>
      Map<K,​V>      		 of()
      返回包含零映射的不可修改映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1)
      返回包含单个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2)
      返回包含两个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3)
      返回包含三个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4)
      返回包含四个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5)
      返回包含五个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6)
      返回包含六个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
      返回包含七个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
      返回包含八个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
      返回包含九个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 of​(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
      返回包含十个映射的不可修改的映射。
      static <K,​V>
      Map<K,​V>      		 ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
      返回包含从给定条目中提取的键和值的不可修改的映射。
      V put​(K key, V value)
      将指定的值与此映射中的指定键相关联（可选操作）。
      void putAll​(Map<? extends K,​? extends V> m)
      将指定映射中的所有映射复制到此映射（可选操作）。
      default V putIfAbsent​(K key, V value)
      如果指定的键尚未与值关联（或映射到 null ）， null其与给定值关联并返回 null ，否则返回当前值。
      V remove​(Object key)
      如果存在，则从该映射中移除键的映射（可选操作）。
      default boolean remove​(Object key, Object value)
      仅当指定键当前映射到指定值时才删除该条目的条目。
      default V replace​(K key, V value)
      仅当指定键当前映射到某个值时，才替换该条目的条目。
      default boolean replace​(K key, V oldValue, V newValue)
      仅当前映射到指定值时，才替换指定键的条目。
      default void replaceAll​(BiFunction<? super K,​? super V,​? extends V> function)
      将每个条目的值替换为在该条目上调用给定函数的结果，直到所有条目都已处理或函数抛出异常。
      int size()
      返回此映射中键 - 值映射的数量。
      Collection<V> values()
      返回此映射中包含的值的Collection视图。

    • 方法详细信息

      • size

        int size()
        返回此映射中键 - 值映射的数量。 如果地图包含超过Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE 。
        结果
        此映射中键 - 值映射的数量

      • isEmpty

        boolean isEmpty()
        如果此映射不包含键 - 值映射，则返回 true 。
        结果
        true如果此映射不包含键 - 值映射

      • containsKey

        boolean containsKey​(Object key)
        如果此映射包含指定键的映射，则返回true 。 更正式地，当且仅当此映射包含键k的映射（例如true时，才返回Objects.equals(key, k) 。 （最多可以有一个这样的映射。）
        参数
        key - 要测试其在此地图中的存在的密钥
        结果
        true如果此映射包含指定键的映射
        异常
        ClassCastException - 如果该地区的密码是不适合的某种类型（ optional ）
        NullPointerException - 如果指定的键为空且此映射不允许空键（ optional ）

      • containsValue

        boolean containsValue​(Object value)
        如果此映射将一个或多个键映射到指定值，则返回true 。 更正式地，返回true当且仅当此映射包含的至少一个映射到一个值v使得Objects.equals(value, v) 。 对于Map接口的大多数实现，此操作可能需要在映射大小中线性时间。
        参数
        value - 要测试其在此映射中的存在的值
        结果
        true如果此映射将一个或多个键映射到指定的值
        异常
        ClassCastException - 如果该地图的数据类型不正确（ optional ）
        NullPointerException - 如果指定的值为null并且此映射不允许空值（ optional ）

      • get

        V get​(Object key)
        返回指定键映射到的值，如果此映射不包含键的映射，则返回null 。

        更正式地说，如果此映射包含从键k到值v的映射，使得Objects.equals(key, k) ，则此方法返回v ; 否则返回null 。 （最多可以有一个这样的映射。）

        如果此映射允许空值，则返回值null 不一定表示映射不包含该键的映射; 地图也可能将密钥明确映射到null 。 可以使用containsKey操作来区分这两种情况。

        参数
        key - 要返回其关联值的键
        结果
        指定键映射到的值，如果此映射不包含键的映射， null
        异常
        ClassCastException - 如果该地区的密码是不适合的某种类型（ optional ）
        NullPointerException - 如果指定的键为空且此映射不允许空键（ optional ）

      • put

        V put​(K key,
      V value)
        将指定的值与此映射中的指定键相关联（可选操作）。 如果映射先前包含键的映射，则旧值将替换为指定的值。 （当且仅当m.containsKey(k)将返回true地图m才会包含密钥k的映射。）
        参数
        key - 与指定值关联的键
        value - 与指定键关联的值
        结果
        与key关联的先前值，如果null没有映射， key 。 （A null返回也可以指示先前与null关联的地图与key ，如果实现支持null值。）
        异常
        UnsupportedOperationException - 如果此地图不支持 put
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中
        NullPointerException - 如果指定的键或值为null，并且此映射不允许空键或值
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中

      • remove

        V remove​(Object key)
        如果存在，则从该映射中移除键的映射（可选操作）。 更正式地说，如果此映射包含从键k到值v的映射，例如Objects.equals(key, k) ，则删除该映射。 （地图最多可以包含一个这样的映射。）

        返回此映射先前与该键关联的值，如果映射不包含该键的映射，则返回null 。

        如果此映射允许空值，则返回值null 不一定表示映射不包含键的映射; 地图也可能明确地将密钥映射到null 。

        一旦调用返回，映射将不包含指定键的映射。

        参数
        key - 要从地图中删除其映射的键
        结果
        与 key关联的先前值，如果 null没有映射， key 。
        异常
        UnsupportedOperationException - 如果此地图不支持 remove操作
        ClassCastException - 如果该地区的密码是不适合的某种类型（ optional ）
        NullPointerException - 如果指定的键为空且此映射不允许空键（ optional ）

      • putAll

        void putAll​(Map<? extends K,​? extends V> m)
        将指定映射中的所有映射复制到此映射（可选操作）。 对于从指定映射中的键k到值v每个映射，此调用的效果等效于在此映射上调用put(k, v)的效果。 如果在操作过程中修改了指定的映射，则此操作的行为是不确定的。
        参数
        m - 要存储在此映射中的映射
        异常
        UnsupportedOperationException - 如果此地图不支持 putAll操作
        ClassCastException - 如果指定映射中的键或值的类阻止它存储在此映射中
        NullPointerException - 如果指定的映射为null，或者此映射不允许空键或值，并且指定的映射包含空键或值
        IllegalArgumentException - 如果指定映射中的键或值的某些属性阻止将其存储在此映射中

      • clear

        void clear()
        从此映射中删除所有映射（可选操作）。 此调用返回后，映射将为空。
        异常
        UnsupportedOperationException - 如果此地图不支持 clear操作

      • keySet

        Set<K> keySet()
        返回此映射中包含的键的Set视图。 该集由地图支持，因此对地图的更改将反映在集中，反之亦然。 如果在对集合进行迭代时修改了映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll ，和clear操作。 它不支持add或addAll操作。
        结果
        此映射中包含的键的设置视图

      • values

        Collection<V> values()
        返回此映射中包含的值的Collection视图。 该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。 如果在对集合进行迭代时修改了映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。 该collection支持元素移除，即从映射中相应的映射，经由Iterator.remove ， Collection.remove ， removeAll ， retainAll和clear操作。 它不支持add或addAll操作。
        结果
        此映射中包含的值的集合视图

      • entrySet

        Set<Map.Entry<K,​V>> entrySet()
        返回此映射中包含的映射的Set视图。 该集由地图支持，因此对地图的更改将反映在集中，反之亦然。 如果在对集合进行迭代时修改了映射（除非通过迭代器自己的remove操作，或者通过迭代器返回的映射条目上的setValue操作），迭代的结果是未定义的。 该组支持元件移除，即从映射中相应的映射，经由Iterator.remove ， Set.remove ， removeAll ， retainAll和clear操作。 它不支持add或addAll操作。
        结果
        此映射中包含的映射的set视图

      • equals

        boolean equals​(Object o)
        将指定对象与此映射进行比较以获得相等性。 如果给定对象也是一个映射，并且两个映射表示相同的映射，则返回true 。 更正式地说，如果m1.entrySet().equals(m2.entrySet()) ，则两个映射m1和m2表示相同的映射。 这可确保equals方法在Map接口的不同实现中正常工作。
        重写：
        equals在类 Object
        参数
        o - 要与此映射进行相等性比较的对象
        结果
        true如果指定的对象等于此映射
        另请参见：
        Object.hashCode() ， HashMap

      • hashCode

        int hashCode()
        返回此映射的哈希码值。 地图的哈希码被定义为地图entrySet()视图中每个条目的哈希码的总和。 这确保m1.equals(m2)暗示m1.hashCode()==m2.hashCode()对于任何两张地图m1和m2 ，按照m2的一般合同的要求 。
        重写：
        hashCode在类 Object
        结果
        此映射的哈希码值
        另请参见：
        Map.Entry.hashCode() ， Object.equals(Object) ， equals(Object)

      • getOrDefault

        default V getOrDefault​(Object key,
                       V defaultValue)
        返回指定键映射到的值，如果此映射不包含键的映射，则返回 defaultValue 。
        实现要求：
        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
        参数
        key - 要返回其关联值的键
        defaultValue - 密钥的默认映射
        结果
        指定键映射到的值，如果此映射不包含键的映射， defaultValue
        异常
        ClassCastException - 如果该地区的密码是不适合的某种类型（ optional ）
        NullPointerException - 如果指定的键为空且此映射不允许空键（ optional ）
        从以下版本开始：
        1.8

      • forEach

        default void forEach​(BiConsumer<? super K,​? super V> action)
        对此映射中的每个条目执行给定操作，直到处理完所有条目或操作引发异常。 除非实现类另有指定，否则将按入口集迭代的顺序执行操作（如果指定了迭代顺序。）操作抛出的异常将中继到调用方。
        实现要求：
        对于此map ，默认实现等效于： 
           for (Map.Entry<K, V> entry : map.entrySet()) action.accept(entry.getKey(), entry.getValue());
        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。
        参数
        action - 要为每个条目执行的操作
        异常
        NullPointerException - 如果指定的操作为null
        ConcurrentModificationException - 如果发现在迭代期间删除了一个条目
        从以下版本开始：
        1.8

      • replaceAll

        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 - 如果指定的函数为null，或者指定的替换值为null，并且此映射不允许空值
        ClassCastException - 如果此地图的替代值的 ClassCastException不合适（ optional ）
        NullPointerException - 如果函数或替换值为null，并且此映射不允许空键或值（ optional ）
        IllegalArgumentException - 如果替换值的某些属性阻止它存储在此映射中（ optional ）
        ConcurrentModificationException - 如果发现在迭代期间删除了一个条目
        从以下版本开始：
        1.8

      • putIfAbsent

        default V putIfAbsent​(K key,
                      V value)
        如果指定的键尚未与值关联（或映射到 null ）， null其与给定值关联并返回 null ，否则返回当前值。
        实现要求：
        对于此map ，默认实现等效于： 
           V v = map.get(key); if (v == null) v = map.put(key, value); return v;

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。

        参数
        key - 与指定值关联的键
        value - 与指定键关联的值
        结果
        与指定键关联的先前值，如果没有键的映射， null 。 （A null返回也可以指示先前与关键字关联的null ，如果实现支持空值。）
        异常
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果此地图的某个或位非常重要类型或值（ optional ）
        NullPointerException - 如果指定的键或值为null，并且此映射不允许空键或值（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止将其存储在此映射中（ optional ）
        从以下版本开始：
        1.8

      • remove

        default boolean remove​(Object key,
                       Object value)
        仅当指定键当前映射到指定值时才删除该条目的条目。
        实现要求：
        对于此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 - 如果此地图的某个或 ClassCastException具有不同的类型的是对于此地图（ optional ）
        NullPointerException - 如果指定的键或值为null，并且此映射不允许空键或值（ optional ）
        从以下版本开始：
        1.8

      • replace

        default boolean replace​(K key,
                        V oldValue,
                        V newValue)
        仅当前映射到指定值时，才替换指定键的条目。
        实现要求：
        对于此map ，默认实现等效于： 
           if (map.containsKey(key) && Objects.equals(map.get(key), value)) { map.put(key, newValue); return true; } else return false;
        如果oldValue为null，则默认实现不会为不支持空值的映射抛出NullPointerException，除非newValue也为null。

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。

        参数
        key - 与指定值关联的键
        oldValue - 期望与指定密钥关联的值
        newValue - 要与指定键关联的值
        结果
        true如果值已被替换
        异常
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中
        NullPointerException - 如果指定的键或newValue为null，并且此映射不允许null键或值
        NullPointerException - 如果oldValue为null且此映射不允许空值（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中
        从以下版本开始：
        1.8

      • replace

        default V replace​(K key,
                  V value)
        仅当指定键当前映射到某个值时，才替换该条目的条目。
        实现要求：
        对于此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 - 如果指定的键或值为null，并且此映射不允许空键或值
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中
        从以下版本开始：
        1.8

      • computeIfAbsent

        default V computeIfAbsent​(K key,
                          Function<? super K,​? extends V> mappingFunction)
        如果指定的键尚未与值关联（或映射到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); }

        默认实现不保证检测映射函数是否在计算期间修改此映射，并在适当时报告错误。 非并发实现应该覆盖此方法，并且如果检测到映射函数在计算期间修改此映射，则在尽力而为的基础上抛出ConcurrentModificationException 。 并发实现应该覆盖此方法，并且如果检测到映射函数在计算期间修改此映射并且因此计算将永远不会完成，则在尽力而为的基础上抛出IllegalStateException 。

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录仅当值不存在时是否原子地应用映射函数。

        参数
        key - 与指定值关联的键
        mappingFunction - 用于计算值的映射函数
        结果
        与指定键关联的当前（现有或已计算）值，如果计算值为null，则为null
        异常
        NullPointerException - 如果指定的键为null且此映射不支持null键，或者mappingFunction为null
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中（ optional ）
        从以下版本开始：
        1.8

      • computeIfPresent

        default V computeIfPresent​(K key,
                           BiFunction<? super K,​? super V,​? extends V> remappingFunction)
        如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。

        如果重映射函数返回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); }

        默认实现不保证检测重映射函数是否在计算期间修改此映射，并在适当时报告错误。 非并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射，则在尽力而为的基础上抛出ConcurrentModificationException 。 并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射并且因此计算将永远不会完成，则在尽力而为的基础上抛出IllegalStateException 。

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录仅当该值不存在时是否原子地应用重映射功能。

        参数
        key - 与指定值关联的键
        remappingFunction - 用于计算值的重映射函数
        结果
        与指定键关联的新值，如果没有，则返回null
        异常
        NullPointerException - 如果指定的键为null且此映射不支持null键，或者remappingFunction为null
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中（ optional ）
        从以下版本开始：
        1.8

      • compute

        default V compute​(K key,
                  BiFunction<? super K,​? super V,​? extends V> remappingFunction)
        尝试计算指定键及其当前映射值的映射（如果没有当前映射， null ）。 例如，要创建或附加String消息到值映射： 
           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; }

        默认实现不保证检测重映射函数是否在计算期间修改此映射，并在适当时报告错误。 非并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射，则在尽力而为的基础上抛出ConcurrentModificationException 。 并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射并且因此计算将永远不会完成，则在尽力而为的基础上抛出IllegalStateException 。

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别是，子接口ConcurrentMap的所有实现必须记录仅当值不存在时是否以原子方式应用重映射功能。

        参数
        key - 与指定值关联的键
        remappingFunction - 用于计算值的重映射函数
        结果
        与指定键关联的新值，如果没有，则返回null
        异常
        NullPointerException - 如果指定的键为null且此映射不支持null键，或者remappingFunction为null
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中（ optional ）
        从以下版本开始：
        1.8

      • merge

        default V merge​(K key,
                V value,
                BiFunction<? super V,​? super V,​? extends V> remappingFunction)
        如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。 否则，将相关值替换为给定重映射函数的结果，或者如果结果为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);

        默认实现不保证检测重映射函数是否在计算期间修改此映射，并在适当时报告错误。 非并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射，则在尽力而为的基础上抛出ConcurrentModificationException 。 并发实现应该覆盖此方法，并且如果检测到重映射函数在计算期间修改此映射并且因此计算将永远不会完成，则在尽力而为的基础上抛出IllegalStateException 。

        默认实现不保证此方法的同步或原子性属性。 提供原子性保证的任何实现都必须覆盖此方法并记录其并发属性。 特别地，子接口ConcurrentMap的所有实现必须记录仅当该值不存在时是否原子地应用重映射功能。

        参数
        key - 与结果值关联的键
        value - 要与与键关联的现有值合并的非空值，或者，如果没有现有值或与键关联的空值，则与键关联
        remappingFunction - 重新映射函数，用于重新计算值（如果存在）
        结果
        与指定键关联的新值，如果没有值与键关联，则返回null
        异常
        UnsupportedOperationException -如果 put操作不受此地图支持（ optional ）
        ClassCastException - 如果指定键或值的类阻止它存储在此映射中（ optional ）
        IllegalArgumentException - 如果指定键或值的某些属性阻止它存储在此映射中（ optional ）
        NullPointerException - 如果指定的键为null且此映射不支持null键或值或remappingFunction为null
        从以下版本开始：
        1.8

      • of

        static <K,​V> Map<K,​V> of()
        返回包含零映射的不可修改映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        结果
        空 Map
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1)
        返回包含单个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - 这个重 Map V是 Map
        参数
        k1 - 映射的密钥
        v1 - 映射的值
        结果
        包含指定映射的 Map
        异常
        NullPointerException - 如果密钥或值为 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2)
        返回包含两个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的键
        v1 - 第一个映射的值
        k2 - 第二个映射的密钥
        v2 - 第二个映射的值
        结果
        a Map包含指定的映射
        异常
        IllegalArgumentException - 如果密钥是重复的
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3)
        返回包含三个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的密钥
        v1 - 第一个映射的值
        k2 - 第二个映射的密钥
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4)
        返回包含四个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的数值类型
        参数
        k1 - 第一个映射的密钥
        v1 - 第一个映射的值
        k2 - 第二个映射的密钥
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的键
        v4 - 第四个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5)
        返回包含五个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的键
        v1 - 第一个映射的值
        k2 - 第二个映射的密钥
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的密钥
        v4 - 第四个映射的值
        k5 - 第五个映射的关键字
        v5 - 第五个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5,
                                     K k6,
                                     V v6)
        返回包含六个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的键
        v1 - 第一个映射的值
        k2 - 第二个映射的键
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的键
        v4 - 第四个映射的值
        k5 - 第五个映射的关键字
        v5 - 第五个映射的值
        k6 - 第六个映射的键
        v6 - 第六个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5,
                                     K k6,
                                     V v6,
                                     K k7,
                                     V v7)
        返回包含七个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - 第 Map的值类型
        参数
        k1 - 第一个映射的密钥
        v1 - 第一个映射的值
        k2 - 第二个映射的键
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的键
        v4 - 第四个映射的值
        k5 - 第五个映射的密钥
        v5 - 第五个映射的值
        k6 - 第六个映射的键
        v6 - 第六个映射的值
        k7 - 第七个映射的关键字
        v7 - 第七个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5,
                                     K k6,
                                     V v6,
                                     K k7,
                                     V v7,
                                     K k8,
                                     V v8)
        返回包含八个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的键
        v1 - 第一个映射的值
        k2 - 第二个映射的键
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的关键字
        v4 - 第四个映射的值
        k5 - 第五个映射的键
        v5 - 第五个映射的值
        k6 - 第六个映射的密钥
        v6 - 第六个映射的值
        k7 - 第七个映射的关键字
        v7 - 第七个映射的值
        k8 - 第八个映射的键
        v8 - 第八个映射的值
        结果
        a Map包含指定的映射
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5,
                                     K k6,
                                     V v6,
                                     K k7,
                                     V v7,
                                     K k8,
                                     V v8,
                                     K k9,
                                     V v9)
        返回包含九个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的数值类型
        参数
        k1 - 第一个映射的密钥
        v1 - 第一个映射的值
        k2 - 第二个映射的密钥
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的键
        v4 - 第四个映射的值
        k5 - 第五个映射的关键字
        v5 - 第五个映射的值
        k6 - 第六个映射的键
        v6 - 第六个映射的值
        k7 - 第七个映射的关键字
        v7 - 第七个映射的值
        k8 - 第八个映射的键
        v8 - 第八个映射的值
        k9 - 第九个映射的密钥
        v9 - 第九个映射的值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • of

        static <K,​V> Map<K,​V> of​(K k1,
                                     V v1,
                                     K k2,
                                     V v2,
                                     K k3,
                                     V v3,
                                     K k4,
                                     V v4,
                                     K k5,
                                     V v5,
                                     K k6,
                                     V v6,
                                     K k7,
                                     V v7,
                                     K k8,
                                     V v8,
                                     K k9,
                                     V v9,
                                     K k10,
                                     V v10)
        返回包含十个映射的不可修改的映射。 有关详细信息，请参见Unmodifiable Maps 。
        参数类型
        K - Map的密钥类型
        V - Map的值类型
        参数
        k1 - 第一个映射的密钥
        v1 - 第一个映射的值
        k2 - 第二个映射的键
        v2 - 第二个映射的值
        k3 - 第三个映射的键
        v3 - 第三个映射的值
        k4 - 第四个映射的键
        v4 - 第四个映射的值
        k5 - 第五个映射的键
        v5 - 第五个映射的值
        k6 - 第六个映射的键
        v6 - 第六个映射的值
        k7 - 第七个映射的关键字
        v7 - 第七个映射的值
        k8 - 第八个映射的键
        v8 - 第八个映射的值
        k9 - 第九个映射的密钥
        v9 - 第九个映射的值
        k10 - 第十个映射的关键字
        v10 - 第十个映射的值
        结果
        a Map包含指定的映射
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何键或值是 null
        从以下版本开始：
        9

      • ofEntries

        @SafeVarargs
static <K,​V> Map<K,​V> ofEntries​(Map.Entry<? extends K,​? extends V>... entries)
        返回包含从给定条目中提取的键和值的不可修改的映射。 条目本身不存储在地图中。 有关详细信息，请参见Unmodifiable Maps 。
        API Note:
        使用Map.entry()方法创建地图条目很方便。 例如， 
           import static java.util.Map.entry; Map<Integer,String> map = Map.ofEntries( entry(1, "a"), entry(2, "b"), entry(3, "c"), ... entry(26, "z"));
        参数类型
        K - Map的密钥类型
        V - Map的数值类型
        参数
        entries - Map.Entry s包含填充地图的键和值
        结果
        包含指定映射的 Map
        异常
        IllegalArgumentException - 如果有任何重复的密钥
        NullPointerException - 如果任何条目，键或值是 null ，或者 entries数组是 null
        从以下版本开始：
        9
        另请参见：
        Map.entry()

      • entry

        static <K,​V> Map.Entry<K,​V> entry​(K k,
                                              V v)
        返回包含给定键和值的不可修改的Map.Entry 。 这些条目适合使用Map.ofEntries()方法填充Map实例。 此方法创建的Entry实例具有以下特征：
        • 他们不允许null键和值。 尝试使用null键或值创建它们导致NullPointerException 。
        • 它们是不可修改的。 拨打Entry.setValue()在返回Entry结果UnsupportedOperationException 。
        • 它们不可序列化。
        • 他们是value-based 。 调用者不应对返回实例的身份做出任何假设。 此方法可以自由创建新实例或重用现有实例。 因此，对这些实例的身份敏感操作（引用相等（ == ），标识哈希代码和同步）是不可靠的，应该避免。
        API Note:
        对于可序列化的Entry ，请参见AbstractMap.SimpleEntry或AbstractMap.SimpleImmutableEntry 。
        参数类型
        K - 密钥的类型
        V - 值的类型
        参数
        k - 钥匙
        v - 该值
        结果
        包含指定键和值的 Entry
        异常
        NullPointerException - 如果密钥或值为 null
        从以下版本开始：
        9
        另请参见：
        Map.ofEntries()

      • copyOf

        static <K,​V> Map<K,​V> copyOf​(Map<? extends K,​? extends V> map)
        返回包含给定Map的条目的unmodifiable Map 。 给定的Map不能为null，并且不能包含任何null键或值。 如果随后修改了给定的Map，则返回的Map将不会反映此类修改。
        Implementation Note:
        如果给定的Map是 unmodifiable Map ，则调用copyOf通常不会创建副本。
        参数类型
        K - 这是关键字的 Map
        V - Map的值类型
        参数
        map - Map绘制条目的 Map必须为非null
        结果
        a Map包含给定 Map的条目
        异常
        NullPointerException - 如果map为null，或者它包含任何null键或值
        从以下版本开始：
        10