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

参数类型

K - 此映射维护的密钥类型

V - 映射值的类型

实现的所有接口

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 ，除了它是不同步的并且允许空值。）此类不保证地图的顺序; 特别是，它不保证订单会随着时间的推移保持不变。
该实现为基本操作（ get和put ）提供了恒定时间性能，假设散列函数在桶之间正确地分散元素。对集合视图的迭代需要与HashMap实例的“容量”（桶数）加上其大小（键值映射的数量）成比例的时间。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或负载因子太低）非常重要。

HashMap的实例有两个影响其性能的参数： 初始容量和负载因子 。容量是哈希表中的桶数，初始容量只是创建哈希表时的容量。 加载因子是在自动增加容量之前允许哈希表获取的完整程度的度量。当哈希表中的条目数超过加载因子和当前容量的乘积时，哈希表将被重新哈希（即，重建内部数据结构），以便哈希表具有大约两倍的桶数。

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

如果要将多个映射存储在HashMap实例中，则使用足够大的容量创建映射将允许映射更有效地存储，而不是根据需要执行自动重新散列来扩展表。请注意，使用具有相同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

嵌套类汇总
- 嵌套类/接口声明在类 java.util.AbstractMap
  AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>
- Nested classes/interfaces declared in interface java.util.Map
  Map.Entry<K,V>

构造方法摘要

构造方法
构造器	描述
`HashMap()`	使用默认初始容量（16）和默认加载因子（0.75）构造一个空 `HashMap` 。
`HashMap(int initialCapacity)`	使用指定的初始容量和默认加载因子（0.75）构造一个空 `HashMap` 。
`HashMap(int initialCapacity, float loadFactor)`	使用指定的初始容量和加载因子构造一个空 `HashMap` 。
`HashMap(Map<? extends K,? extends V> m)`	构造一个新的 `HashMap` ，其映射与指定的 `Map`相同。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`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)`	如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。
`boolean`	`containsKey(Object key)`	如果此映射包含指定键的映射，则返回 `true` 。
`boolean`	`containsValue(Object value)`	如果此映射将一个或多个键映射到指定值，则返回 `true` 。
`Set<Map.Entry<K,V>>`	`entrySet()`	返回此映射中包含的映射的`Set`视图。
`V`	`get(Object key)`	返回指定键映射到的值，如果此映射不包含键的映射，则返回 `null` 。
`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`	`remove(Object key)`	从此映射中删除指定键的映射（如果存在）。
`int`	`size()`	返回此映射中键 - 值映射的数量。
`Collection<V>`	`values()`	返回此映射中包含的值的`Collection`视图。

声明方法的类 java.util.AbstractMap
equals, hashCode, toString

声明方法的类 java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

声明方法的接口 java.util.Map
equals, forEach, getOrDefault, hashCode, putIfAbsent, remove, replace, replace, replaceAll

- 构造方法详细信息
  - HashMap
```
public HashMap(int initialCapacity,               float loadFactor)
```
    使用指定的初始容量和加载因子构造一个空 HashMap 。
    
    参数
    
    initialCapacity - 初始容量
    
    loadFactor - 负载系数
    
    异常
    
    IllegalArgumentException - 如果初始容量为负或负载因子为非正数
  - HashMap
```
public HashMap(int initialCapacity)
```
    使用指定的初始容量和默认加载因子（0.75）构造一个空 HashMap 。
    
    参数
    
    initialCapacity - 初始容量。
    
    异常
    
    IllegalArgumentException - 如果初始容量为负数。
  - HashMap
```
public HashMap()
```
    使用默认初始容量（16）和默认加载因子（0.75）构造一个空 HashMap 。
  - HashMap
```
public HashMap(Map<? extends K,? extends V> m)
```
    构造一个新的HashMap ，其映射与指定的Map相同。 HashMap创建时使用默认加载因子（0.75）和足以保存指定Map映射的初始容量。
    
    参数
    
    m - m映射放在此映射中的映射
    
    异常
    
    NullPointerException - 如果指定的映射为null
- 方法详细信息
  - 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 - 如果指定的映射为null
  - remove
```
public V remove(Object key)
```
    从此映射中删除指定键的映射（如果存在）。
    
    Specified by:
    
    remove在界面 Map<K,V>
    
    重写：
    
    remove在类 AbstractMap<K,V>
    
    参数
    
    key - 要从地图中删除其映射的键
    
    结果
    
    如果没有key映射，则与key或null关联的先前值。（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>
    
    结果
    
    此映射中包含的映射的set视图
  - computeIfAbsent
```
public 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);
    
    映射函数不应在计算期间修改此映射。
    
    如果检测到映射函数在计算期间修改了该映射，则该方法将在尽力而为的基础上抛出ConcurrentModificationException 。
    Specified by:
    
    computeIfAbsent在界面 Map<K,V>
    
    参数
    
    key - 与指定值关联的键
    
    mappingFunction - 用于计算值的映射函数
    
    结果
    
    与指定键关联的当前（现有或已计算）值，如果计算值为null，则为null
    
    异常
    
    ConcurrentModificationException - 如果检测到映射函数修改了此映射
  - computeIfPresent
```
public V computeIfPresent(K key,                          BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。
    如果重映射函数返回null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并保持当前映射不变。
    
    重映射功能不应在计算期间修改此映射。
    
    如果检测到重映射函数在计算期间修改了该映射，则该方法将在尽力而为的基础上抛出ConcurrentModificationException 。
    
    Specified by:
    
    computeIfPresent在界面 Map<K,V>
    
    参数
    
    key - 与指定值关联的键
    
    remappingFunction - 用于计算值的重映射函数
    
    结果
    
    与指定键关联的新值，如果没有，则返回null
    
    异常
    
    ConcurrentModificationException - 如果检测到重映射功能修改了此映射
  - compute
```
public 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 ，则删除映射（或者如果最初不存在则保持不存在）。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并保持当前映射不变。
    
    重映射功能不应在计算期间修改此映射。
    
    如果检测到重映射函数在计算期间修改该映射，则该方法将尽力地抛出ConcurrentModificationException 。
    Specified by:
    
    compute在界面 Map<K,V>
    
    参数
    
    key - 与指定值关联的键
    
    remappingFunction - 用于计算值的重映射函数
    
    结果
    
    与指定键关联的新值，如果没有，则返回null
    
    异常
    
    ConcurrentModificationException - 如果检测到重映射功能修改了此映射
  - merge
```
public V merge(K key,               V value,               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    如果指定的键尚未与值关联或与null关联，则将其与给定的非空值关联。否则，将相关值替换为给定重映射函数的结果，或者如果结果为null则将其删除。当组合密钥的多个映射值时，该方法可以是有用的。例如，要创建或附加String msg到值映射：
    map.merge(key, msg, String::concat)
    
    如果重映射函数返回null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并保持当前映射不变。
    
    重映射功能不应在计算期间修改此映射。
    
    如果检测到重映射函数在计算期间修改了该映射，则该方法将在尽力而为的基础上抛出ConcurrentModificationException 。
    Specified by:
    
    merge在界面 Map<K,V>
    
    参数
    
    key - 与结果值关联的键
    
    value - 要与与键关联的现有值合并的非空值，或者，如果没有现有值或与键关联的空值，则与键关联
    
    remappingFunction - 重新映射函数，用于重新计算值（如果存在）
    
    结果
    
    与指定键关联的新值，如果没有值与键关联，则返回null
    
    异常
    
    ConcurrentModificationException - 如果检测到重映射功能修改了此映射
  - clone
```
public Object clone()
```
    返回此 HashMap实例的浅表副本：未克隆键和值本身。
    
    重写：
    
    clone类 AbstractMap<K,V>
    
    结果
    
    这张地图的浅表副本
    
    另请参见：
    
    Cloneable

Class HashMap<K,​V>

嵌套类汇总

嵌套类/接口声明在类 java.util.AbstractMap

Nested classes/interfaces declared in interface java.util.Map

构造方法摘要

方法摘要

声明方法的类 java.util.AbstractMap

声明方法的类 java.lang.Object

声明方法的接口 java.util.Map

构造方法详细信息

HashMap

HashMap

HashMap

HashMap

方法详细信息

size

isEmpty

get

containsKey

put

putAll

remove

clear

containsValue

keySet

values

entrySet

computeIfAbsent

computeIfPresent

compute

merge

clone

Class HashMap<K,V>