HashMap (Java Platform SE 8 )

java.lang.Object
- java.util.AbstractMap<K,V>
- - java.util.HashMap<K,V>

参数类型

K - 由该地图维护的键的类型

V - 映射值的类型

All Implemented Interfaces:

Serializable ， Cloneable ， Map <K，V>

已知直接子类：

LinkedHashMap ， PrinterStateReasons
```
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
```
基于哈希表的实现的Map接口。此实现提供了所有可选的地图操作，并允许null的值和null键。（ HashMap类大致相当于Hashtable ，除了它是不同步的，并允许null）。这个类不能保证地图的顺序; 特别是，它不能保证订单在一段时间内保持不变。
假设哈希函数在这些存储桶之间正确分散元素，这个实现为基本操作（ get和put ）提供了恒定的时间性能。收集视图的迭代需要与HashMap实例（桶数）加上其大小（键值映射数）的“容量” 成正比 。因此，如果迭代性能很重要，不要将初始容量设置得太高（或负载因子太低）是非常重要的。

HashMap的一个实例有两个影响其性能的参数： 初始容量和负载因子 。容量是哈希表中的桶数，初始容量只是创建哈希表时的容量。 负载因子是在容量自动增加之前允许哈希表得到满足的度量。当在散列表中的条目的数量超过了负载因数和电流容量的乘积，哈希表被重新散列 （即，内部数据结构被重建），使得哈希表具有桶的大约两倍。

作为一般规则，默认负载因子（.75）提供了时间和空间成本之间的良好折中。更高的值会降低空间开销，但会增加查找成本（反映在HashMap类的大部分操作中，包括get和put ）。在设置其初始容量时，应考虑地图中预期的条目数及其负载因子，以便最小化重新组播操作的数量。如果初始容量大于最大条目数除以负载因子，则不会发生重新排列操作。

如果许多映射要存储在HashMap实例中，则以足够大的容量创建映射将允许映射的存储效率高于使其根据需要执行自动重新排序以增长表。请注意，使用同一个hashCode()多个密钥是降低任何哈希表的hashCode()的一种方法。为了改善影响，当按键是Comparable时，这个类可以使用键之间的比较顺序来帮助打破关系。

请注意，此实现不同步。 如果多个线程同时访问哈希映射，并且至少有一个线程在结构上修改了映射，那么它必须在外部进行同步。（结构修改是添加或删除一个或多个映射的任何操作;仅改变与实例已经包含的密钥相关联的值不是结构修改。）这通常通过对自然地封装映射的一些对象进行同步来实现。如果没有这样的对象存在，地图应该使用Collections.synchronizedMap方法“包装”。这最好在创建时完成，以防止意外的不同步访问地图：
```
  Map m = Collections.synchronizedMap(new HashMap(...)); 
```
所有这个类的“集合视图方法”返回的迭代器都是故障快速的 ：如果映射在迭代器创建之后的任何时间被结构地修改，除了通过迭代器自己的remove方法之外，迭代器将抛出一个ConcurrentModificationException 。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。

请注意，迭代器的故障快速行为无法保证，因为一般来说，在不同步并发修改的情况下，无法做出任何硬性保证。失败快速迭代器尽力扔掉ConcurrentModificationException 。因此，编写依赖于此异常的程序的正确性将是错误的：迭代器的故障快速行为应仅用于检测错误。

这个班是Java Collections Framework的会员。
从以下版本开始：

1.2

另请参见：

Object.hashCode() ， Collection ， Map ， TreeMap ， Hashtable ， Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

构造方法摘要

构造方法
Constructor and Description
`HashMap()` 构造一个空的 `HashMap` ，默认初始容量（16）和默认负载系数（0.75）。
`HashMap(int initialCapacity)` 构造一个空的 `HashMap`具有指定的初始容量和默认负载因子（0.75）。
`HashMap(int initialCapacity, float loadFactor)` 构造一个空的 `HashMap`具有指定的初始容量和负载因子。
`HashMap(Map<? extends K,? extends V> m)` 构造一个新的 `HashMap`与指定的相同的映射 `Map` 。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`void`	`clear()` 从这张地图中删除所有的映射。
`Object`	`clone()` 返回此 `HashMap`实例的浅拷贝：键和值本身不被克隆。
`V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 尝试计算用于指定键和其当前映射的值的映射（或 `null`如果没有当前映射）。
`V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)` 如果指定的键尚未与值相关联（或映射到 `null` ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 `null` 。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
`boolean`	`containsKey(Object key)` 如果此映射包含指定键的映射，则返回 `true` 。
`boolean`	`containsValue(Object value)` 如果此地图将一个或多个键映射到指定值，则返回 `true` 。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回此地图中包含的映射的`Set`视图。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)` 返回到指定键所映射的值，或 `null`如果此映射包含该键的映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回到指定键所映射的值，或 `defaultValue`如果此映射包含该键的映射。
`boolean`	`isEmpty()` 如果此地图不包含键值映射，则返回 `true` 。
`Set<K>`	`keySet()` 返回此地图中包含的键的`Set`视图。
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)` 如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
`V`	`put(K key, V value)` 将指定的值与此映射中的指定键相关联。
`void`	`putAll(Map<? extends K,? extends V> m)` 将指定地图的所有映射复制到此地图。
`V`	`putIfAbsent(K key, V value)` 如果指定的键尚未与某个值相关联（或映射到 `null` ），则将其与给定值相关联并返回 `null` ，否则返回当前值。
`V`	`remove(Object key)` 从该地图中删除指定键的映射（如果存在）。
`boolean`	`remove(Object key, Object value)` 仅当指定的密钥当前映射到指定的值时删除该条目。
`V`	`replace(K key, V value)` 只有当目标映射到某个值时，才能替换指定键的条目。
`boolean`	`replace(K key, V oldValue, V newValue)` 仅当当前映射到指定的值时，才能替换指定键的条目。
`void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)` 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
`int`	`size()` 返回此地图中键值映射的数量。
`Collection<V>`	`values()` 返回此地图中包含的值的`Collection`视图。

Methods inherited from class java.util.AbstractMap
equals, hashCode, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
equals, hashCode

- 构造方法详细信息
  - HashMap
```
public HashMap(int initialCapacity,
               float loadFactor)
```
    构造一个空的 HashMap具有指定的初始容量和负载因子。
    
    参数
    
    initialCapacity - 初始容量
    
    loadFactor - 负载因子
    
    异常
    
    IllegalArgumentException - 如果初始容量为负值或负载系数为非正值
  - HashMap
```
public HashMap(int initialCapacity)
```
    构造一个空的 HashMap ，具有指定的初始容量和默认负载系数（0.75）。
    
    参数
    
    initialCapacity - 初始容量。
    
    异常
    
    IllegalArgumentException - 如果初始容量为负。
  - HashMap
```
public HashMap()
```
    构造一个空的 HashMap ，默认初始容量（16）和默认负载因子（0.75）。
  - HashMap
```
public HashMap(Map<? extends K,? extends V> m)
```
    构造一个新的HashMap与指定的相同的映射Map 。该HashMap与默认负载因数（0.75）和初始容量足以容纳映射在指定Map创建。
    
    参数
    
    m - 其映射将放置在此映射中的映射
    
    异常
    
    NullPointerException - 如果指定的地图为空
- 方法详细信息
  - size
```
public int size()
```
    返回此地图中键值映射的数量。
    
    Specified by:
    
    size在界面 Map<K,V>
    
    重写：
    
    size在类别 AbstractMap<K,V>
    
    结果
    
    该地图中键值映射的数量
  - isEmpty
```
public boolean isEmpty()
```
    如果此地图不包含键值映射，则返回 true 。
    
    Specified by:
    
    isEmpty在界面 Map<K,V>
    
    重写：
    
    isEmpty在类别 AbstractMap<K,V>
    
    结果
    
    true如果此映射不包含键值映射
  - get
```
public V get(Object key)
```
    返回到指定键所映射的值，或null如果此映射包含该键的映射。
    更正式地，如果该映射包含从键k到值v ，使得(key==null ? k==null : key.equals(k)) ，则该方法返回v ; 否则返回null 。（最多可以有一个这样的映射。）
    
    返回值null并不一定表示该映射不包含该键的映射; 地图也可能明确地将密钥映射到null 。可以使用containsKey操作来区分这两种情况。
    
    Specified by:
    
    get在界面 Map<K,V>
    
    重写：
    
    get在类别 AbstractMap<K,V>
    
    参数
    
    key - 要返回其关联值的键
    
    结果
    
    指定键映射到的值，如果此映射不包含键的映射， null
    
    另请参见：
    
    put(Object, Object)
  - containsKey
```
public boolean containsKey(Object key)
```
    如果此映射包含指定键的映射，则返回 true 。
    
    Specified by:
    
    containsKey在界面 Map<K,V>
    
    重写：
    
    containsKey在类别 AbstractMap<K,V>
    
    参数
    
    key - 要在这个地图上存在的密钥是要测试的
    
    结果
    
    true如果此映射包含指定键的映射。
  - put
```
public V put(K key,
             V value)
```
    将指定的值与此映射中的指定键相关联。如果地图先前包含了该键的映射，则替换旧值。
    
    Specified by:
    
    put在界面 Map<K,V>
    
    重写：
    
    put在类别 AbstractMap<K,V>
    
    参数
    
    key - 指定值与之关联的键
    
    value - 与指定键相关联的值
    
    结果
    
    前一个值与key相关联 ，或null如果没有key的映射。（A null返回也可以指示以前关联的地图null与key。 ）
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    将指定地图的所有映射复制到此地图。这些映射将替换此映射对当前在指定映射中的任何键的任何映射。
    
    Specified by:
    
    putAll在界面 Map<K,V>
    
    重写：
    
    putAll在 AbstractMap<K,V>
    
    参数
    
    m - 存储在此地图中的映射
    
    异常
    
    NullPointerException - 如果指定的地图为空
  - remove
```
public V remove(Object key)
```
    从该地图中删除指定键的映射（如果存在）。
    
    Specified by:
    
    remove在界面 Map<K,V>
    
    重写：
    
    remove在类别 AbstractMap<K,V>
    
    参数
    
    key - 要从地图中删除其映射的密钥
    
    结果
    
    前一个值与key相关联 ，或null如果没有映射为key 。（A null返回也可以指示以前关联的地图null与key。 ）
  - clear
```
public void clear()
```
    从这张地图中删除所有的映射。此呼叫返回后，地图将为空。
    
    Specified by:
    
    clear在界面 Map<K,V>
    
    重写：
    
    clear在 AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    如果此地图将一个或多个键映射到指定的值，则返回 true 。
    
    Specified by:
    
    containsValue在界面 Map<K,V>
    
    重写：
    
    containsValue在类别 AbstractMap<K,V>
    
    参数
    
    value - 要在此地图中存在的值要进行测试
    
    结果
    
    true如果该地图将一个或多个键映射到指定的值
  - keySet
```
public Set<K> keySet()
```
    返回此地图中包含的键的Set视图。该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。该组支持元件移除，即从映射中相应的映射，经由Iterator.remove，Set.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    keySet在界面 Map<K,V>
    
    重写：
    
    keySet在类别 AbstractMap<K,V>
    
    结果
    
    该地图中包含的键的集合视图
  - values
```
public Collection<V> values()
```
    返回此地图中包含的值的Collection视图。集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。该collection支持元素移除，即从映射中相应的映射，经由Iterator.remove，Collection.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    values在界面 Map<K,V>
    
    重写：
    
    values在类别 AbstractMap<K,V>
    
    结果
    
    该地图中包含的值的视图
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    返回此地图中包含的映射的Set视图。该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。如果在集合中的迭代（除了通过迭代器自己的remove操作，或通过迭代器返回的映射条目上的setValue操作之外）修改映射，则迭代的结果是未定义的。该组支持元件移除，即从映射中相应的映射，经由Iterator.remove，Set.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    entrySet在界面 Map<K,V>
    
    Specified by:
    
    entrySet在 AbstractMap<K,V>
    
    结果
    
    该地图中包含的映射的集合视图
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    说明从界面： Map复制
    
    返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。
    
    Specified by:
    
    getOrDefault在界面 Map<K,V>
    
    参数
    
    key - 要返回其关联值的键
    
    defaultValue - 键的默认映射
    
    结果
    
    指定键映射到的值，如果此映射不包含该键的映射， defaultValue
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    说明从界面： Map复制
    
    如果指定的键尚未与某个值相关联（或映射到 null ），则将其与给定值相关联并返回 null ，否则返回当前值。
    
    Specified by:
    
    putIfAbsent在界面 Map<K,V>
    
    参数
    
    key - 指定值与之关联的键
    
    value - 与指定键相关联的值
    
    结果
    
    与指定键相关联的上一个值，如果没有键的映射， null 。（A null返回也可以指示以前关联的映射关系为null ，如果实现支持空值）。
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    描述从接口： Map复制
    
    仅当指定的密钥当前映射到指定的值时删除该条目。
    
    Specified by:
    
    remove在界面 Map<K,V>
    
    参数
    
    key - 与指定值相关联的键
    
    value - 预期与指定键相关联的值
    
    结果
    
    true如果该值被删除
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    说明从界面： Map复制
    
    仅当当前映射到指定的值时，才能替换指定键的条目。
    
    Specified by:
    
    replace在界面 Map<K,V>
    
    参数
    
    key - 与指定值相关联的键
    
    oldValue - 预期与指定键相关联的值
    
    newValue - 与指定键相关联的值
    
    结果
    
    true如果该值被替换
  - replace
```
public V replace(K key,
                 V value)
```
    说明从界面： Map复制
    
    只有当目标映射到某个值时，才能替换指定键的条目。
    
    Specified by:
    
    replace在界面 Map<K,V>
    
    参数
    
    key - 与指定值相关联的键
    
    value - 与指定键相关联的值
    
    结果
    
    与指定键相关联的上一个值，如果没有键的映射， null 。（A null返回也可以指示以前关联的地图null与关键字，如果实现支持null值。）
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)
```
    说明从界面： Map复制
    如果指定的键尚未与值相关联（或映射到null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非null 。
    如果函数返回null则不记录映射。如果函数本身引发（未检查）异常，则异常被重新引导，并且不记录映射。最常见的用法是构造一个用作初始映射值或记忆结果的新对象，如：
```
   map.computeIfAbsent(key, k -> new Value(f(k)));  
```
    或者实现一个多值地图， Map<K,Collection<V>> ，每个键支持多个值：
```
   map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);  
```
    Specified by:
    
    computeIfAbsent在界面 Map<K,V>
    
    参数
    
    key - 指定值与之关联的键
    
    mappingFunction - 计算值的函数
    
    结果
    
    与指定键相关联的当前（现有或计算）值，如果计算值为空，则为null
  - computeIfPresent
```
public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    描述从界面： Map复制
    
    如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
    如果函数返回null ，则删除映射。如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
    
    Specified by:
    
    computeIfPresent在界面 Map<K,V>
    
    参数
    
    key - 指定值与之关联的键
    
    remappingFunction - 计算值的函数
    
    结果
    
    与指定键相关的新值，如果没有则为null
  - compute
```
public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    描述从界面： Map复制
    尝试计算用于指定键和其当前映射的值的映射（或null如果没有当前映射）。例如，要为值映射创建或附加一个String msg：
```
   map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg)) 
```
    （方法merge()通常更容易用于此类目的。）
    如果函数返回null ，映射将被删除（如果最初缺少，则保持不存在）。如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
    Specified by:
    
    compute在界面 Map<K,V>
    
    参数
    
    key - 要与指定值相关联的键
    
    remappingFunction - 计算值的函数
    
    结果
    
    与指定键相关的新值，如果没有则为null
  - merge
```
public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    说明从界面： Map复制
    如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。否则，将关联值替换为给定重映射函数的结果，如果结果为null 。当组合键的多个映射值时，该方法可能是有用的。例如，要创建或追加String msg到值映射：
```
   map.merge(key, msg, String::concat)  
```
    如果函数返回null ，则删除映射。如果函数本身引发（未检查）异常，则异常被重新引导，并且当前映射保持不变。
    Specified by:
    
    merge在界面 Map<K,V>
    
    参数
    
    key - 与结果值相关联的键
    
    value - 要与与密钥相关联的现有值合并的非空值，或者如果没有与密钥相关联的现有值或空值与密钥相关联
    
    remappingFunction - 重新计算值（如果存在）的功能
    
    结果
    
    与指定键相关联的新值，如果没有值与该键相关联，则返回null
  - forEach
```
public void forEach(BiConsumer<? super K,? super V> action)
```
    说明从界面： Map复制
    
    对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。除非实现类另有指定，否则按照进入设置迭代的顺序执行操作（如果指定了迭代顺序）。操作引发的异常被转发给调用者。
    
    Specified by:
    
    forEach在界面 Map<K,V>
    
    参数
    
    action - 为每个条目执行的操作
  - replaceAll
```
public void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```
    说明从界面： Map复制
    
    将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。函数抛出的异常被转发给调用者。
    
    Specified by:
    
    replaceAll在界面 Map<K,V>
    
    参数
    
    function - 应用于每个条目的功能
  - clone
```
public Object clone()
```
    返回此 HashMap实例的浅拷贝：键和值本身不被克隆。
    
    重写：
    
    clone在类别 AbstractMap<K,V>
    
    结果
    
    这张地图的浅拷贝
    
    另请参见：
    
    Cloneable

Class HashMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap

Nested classes/interfaces inherited from interface java.util.Map

构造方法摘要

方法摘要

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

构造方法详细信息

HashMap

HashMap

HashMap

HashMap

方法详细信息

size

isEmpty

get

containsKey

put

putAll

remove

clear

containsValue

keySet

values

entrySet

getOrDefault

putIfAbsent

remove

replace

replace

computeIfAbsent

computeIfPresent

compute

merge

forEach

replaceAll

clone