HashMap (Java Platform SE 8 )

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

参数类型

K -钥匙的Map保持型

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接口的实现。这种实现提供了所有可选的Map操作，并允许 null值和 null关键。（这 HashMap类大致相当于 Hashtable，除了它是不同步的，允许空值。）这类做任何保证Map的秩序；特别是，它并不能保证订单将随时间保持恒定。
这个实现的基本操作提供了稳定的性能（get和put），假设哈希函数的分散元素之间的正确的桶。在集合视图迭代需要时间成正比的“能力”的HashMap实例（桶的数量）加上其尺寸（键值对映射的数量）。因此，它是非常重要的，不设置的初始容量太高（或负载因子太低），如果迭代性能是重要的。

对HashMap实例有影响其性能的两个参数：初始容量和负载因子。是的容量哈希表中的存储桶的数目，和初始容量仅仅是当时的哈希表的创建能力。的负载因子是如何全面衡量哈希表是可以在其容量自动增加。当哈希表中的条目数超过负荷的因素和当前容量的乘积，哈希表是重复（即内部数据结构重建），哈希表有大约两倍的存储桶的数目。

作为一个一般规则，默认负载因子（。75）提供了一个很好的时间和空间成本之间的权衡。较高的值会降低空间开销，但提高查找成本（体现在大多数的HashMap类的操作，包括get和put）。预计参赛人数在Map及其负载系数应考虑设置其初始容量时，以尽量减少重复操作的次数。如果初始容量大于最大条目数除以负载因子，没有rehash操作将不会发生。

如果许多映射将被存储在一个HashMap实例，创建了一个足够大的容量将允许映射可以存储比让它执行自动改写为增长所需要的表格更有效。注意使用多键同hashCode()是一个肯定的方式来减缓任何哈希表的性能。改善的影响，Comparable键时，这类可以帮助打破关系键比较的顺序使用。

请注意，此实现不同步。如果多个线程访问一个哈希映射的同时，并至少有一个线程修改Map的结构，它必须同步外部。（结构上的修改是任何操作，添加或删除一个或多个映射；仅仅改变一个关键实例已经包含了不是一个结构上的修改。相关的价值）这通常是由一些对象同步自然封装图完成。如果该对象不存在，Map应该是“包裹”使用Collections.synchronizedMap方法。最好的做法是在创建时，防止意外的非同步访问的Map：
```
MapM =集合。synchronizedmap（新HashMap（…））；
```
所有这一类的“集合视图的方法”快速失败返回的迭代器：如果Map的结构修改，迭代器创建后的任何时间，以任何方式除了通过迭代器的remove方法，迭代器将抛出一个ConcurrentModificationException。因此，在并发修改的面前，迭代器失败迅速和干净，而不是冒着任意的，非确定性的行为在未来的一个不确定的时间。

注意迭代器不能快速失败行为得到保证的话，一般来说，不可能在不同步的并发修改的存在作出难以保证。快速失败迭代器扔ConcurrentModificationException尽最大努力的基础上。因此，要写一个程序，依靠这一例外的正确性错误：快速失败迭代器的行为只能用来检测错误。

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

一点二

另请参见：

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`），尝试使用给定的映射功能，进入到这个Map除非 `null`计算其价值。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果指定键的值是存在和非空的，尝试计算一个新的映射，给出了键和它当前的映射值。
`boolean`	`containsKey(Object key)` 返回 `true`如果这Map包含一个指定的键映射。
`boolean`	`containsValue(Object value)` 返回 `true`如果映射到指定的值的一个或多个键。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回一个 `Set`视图的映射包含在这个Map。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。
`V`	`get(Object key)` 返回指定的键映射的值，或 `null`如果这个Map不包含的键映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回指定的键映射的值，或 `defaultValue`如果这个Map不包含的键映射。
`boolean`	`isEmpty()` 返回 `true`如果这个Map不包含键值的映射。
`Set<K>`	`keySet()` 返回一个 `Set`的关键视图包含在这个Map。
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)` 如果指定的键已与值相关联的值或与空值相关联的，则将其与给定的非空值关联。
`V`	`put(K key, V value)` 将指定的值与此映射中的指定键关联。
`void`	`putAll(Map<? extends K,? extends V> m)` 从指定的映射到该Map的所有映射。
`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`视图的值包含在这个Map。

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

- Constructor Detail
  - 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的映射被放置在这个Map的Map
    
    异常
    
    NullPointerException -如果指定的Map是空的
- 方法详细信息
  - size
```
public int size()
```
    返回这个映射中的键值映射的数目。
    
    Specified by:
    
    size 接口 Map<K,V>
    
    重写：
    
    size 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    在这个映射中的键值映射的数目
  - isEmpty
```
public boolean isEmpty()
```
    返回 true如果这个Map不包含键值的映射。
    
    Specified by:
    
    isEmpty 接口 Map<K,V>
    
    重写：
    
    isEmpty 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    true如果这个Map不包含键值的映射
  - get
```
public V get(Object key)
```
    返回指定的键映射的值，或 null如果这个Map不包含的键映射。
    更正式地说，如果这个图中包含了从关键k到价值v这样(key==null ? k==null : key.equals(k))映射，那么这个方法返回v；否则返回null。（最多只能有一个这样的映射。）
    
    一个null返回值不必要地表明Map不包含的键映射；也有可能是Map明确地映射到null的关键，containsKey操作可用于区分这两例。
    
    Specified by:
    
    get 接口 Map<K,V>
    
    重写：
    
    get 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    结果
    
    值，指定的键映射，或 null如果这个Map不包含的键映射
    
    另请参见：
    
    put(Object, Object)
  - containsKey
```
public boolean containsKey(Object key)
```
    返回 true如果这Map包含一个指定的键映射。
    
    Specified by:
    
    containsKey 接口 Map<K,V>
    
    重写：
    
    containsKey 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key -关键的在这个Map的存在是进行测试
    
    结果
    
    true如果这Map包含一个指定的键映射。
  - put
```
public V put(K key,
             V value)
```
    将指定的值与此映射中的指定键关联。如果映射以前包含一个键的映射，旧值将被替换。
    
    Specified by:
    
    put 接口 Map<K,V>
    
    重写：
    
    put 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    value值必须与指定键关联
    
    结果
    
    与 key以前的值，或者 null如果没有映射的 key。（一 null返回也表明Map以前相关的 null与 key。）
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    从指定的映射到该Map的所有映射。这些映射将取代当前在指定Map中的任何键的任何映射。
    
    Specified by:
    
    putAll 接口 Map<K,V>
    
    重写：
    
    putAll 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    m映射被存储在这个Map
    
    异常
    
    NullPointerException -如果指定的Map是空的
  - remove
```
public V remove(Object key)
```
    如果存在的话，从这个映射中移除指定的键的映射。
    
    Specified by:
    
    remove 接口 Map<K,V>
    
    重写：
    
    remove 方法重写，继承类 AbstractMap<K,V>
    
    参数
    
    key键的映射是从Map上移除
    
    结果
    
    与 key以前的值，或者 null如果没有映射的 key。（一 null返回也表明Map以前相关的 null与 key。）
  - clear
```
public void clear()
```
    从这个映射中移除所有的映射。这个调用返回后的Map将是空的。
    
    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>
    
    参数
    
    在这张Map上 value -它的存在价值进行测试
    
    结果
    
    如果这 true映射到指定的值的一个或多个键
  - keySet
```
public Set<K> keySet()
```
    返回一个 Set查看键包含在这个Map。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的 remove操作），迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Set.remove， removeAll， retainAll，和 clear操作。它不支持 add或 addAll操作。
    
    Specified by:
    
    keySet 接口 Map<K,V>
    
    重写：
    
    keySet 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    在这个Map中包含的键的一个集合视图
  - values
```
public Collection<V> values()
```
    返回一个 Collection视图的值包含在这个Map。集合是由Map支持的，所以对Map的变化反映在集合中，反之亦然。如果Map是在集合的迭代进行修改（除非通过迭代器的 remove操作），迭代的结果是不确定的。收集支持元素的去除，从Map中移除相应的映射，通过 Iterator.remove， Collection.remove， removeAll， retainAll和 clear操作。它不支持 add或 addAll操作。
    
    Specified by:
    
    values 接口 Map<K,V>
    
    重写：
    
    values 方法重写，继承类 AbstractMap<K,V>
    
    结果
    
    此Map中包含的值的视图
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    返回一个 Set视图的映射包含在这个Map。该集合是由Map的支持，所以对Map的变化反映在集合中，反之亦然。如果Map是在设置一个迭代过程中修改（除非通过迭代器的 remove操作，或通过 setValue操作返回的迭代器的映射项）的迭代的结果是不确定的。设置支持元素的去除，从Map中移除相应的映射，通过 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如果这个Map不包含的键映射。
    
    Specified by:
    
    getOrDefault 接口 Map<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    defaultValue -键的默认映射
    
    结果
    
    值，指定的键映射，或 defaultValue如果这个Map不包含的键映射
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    从接口复制的描述： Map
    
    如果指定的键是不是已经与价值相关的（或映射到 null）将其与给定的值并返回 null，否则返回当前值。
    
    Specified by:
    
    putIfAbsent 接口 Map<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    value值必须与指定键关联
    
    结果
    
    与指定的键相关联的前一个值，或 null如果没有键映射。（一 null返回也表明，与先前的 nullMap的关键，如果实施支持空值。）
  - 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如果没有键映射。（一 null返回也表明，与先前的 nullMap的关键，如果实施支持空值。）
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)
```
    从接口复制的描述： Map
    如果指定的键是不是已经与价值相关的（或映射到 null），尝试使用给定的映射功能，进入到这个Map除非 null计算其价值。
    如果函数返回null没有映射记录。如果函数抛出一个（没有）异常，异常会被重新抛出，没有映射记录。最常见的用法是构造一个新对象作为初始映射值或memoized的结果，如：
```
 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的函数来计算一个值
    
    结果
    
    如果计算的值为空，则与指定的键相关联的当前（现有的或计算的）值
  - computeIfPresent
```
public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    从接口复制的描述： Map
    
    如果指定键的值是存在和非空的，尝试计算一个新的映射，给出了键和它当前的映射值。
    如果函数返回null，映射被删除。如果函数抛出一个（没有）异常，异常会被重新抛出，和当前映射保持不变。
    
    Specified by:
    
    computeIfPresent 接口 Map<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    remappingFunction的函数来计算一个值
    
    结果
    
    与指定的键相关联的新值，或为空
  - compute
```
public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    从接口复制的描述： Map
    试图计算出指定键和当前的映射值的映射（或 null如果没有当前映射）。例如，可以创建或追加 String味精到值的映射：
```
 map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
```
    （方法 merge()往往更容易使用等目的。）
    如果函数返回null，映射被删除（或没有如果当初缺席）。如果函数抛出一个（没有）异常，异常会被重新抛出，和当前映射保持不变。
    Specified by:
    
    compute 接口 Map<K,V>
    
    参数
    
    key键与指定的值是相关联的
    
    remappingFunction的函数来计算一个值
    
    结果
    
    与指定的键相关联的新值，或为空
  - merge
```
public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    从接口复制的描述： Map
    如果指定的键已与值相关联的值或与空值相关联的，则将其与给定的非空值关联。否则，将相关值结果与给定的映射函数，或删除如果结果是 null。此方法可以将多个映射值组合在一个键时使用。例如，可以创建或追加 String msg到值的映射：
```
 map.merge(key, msg, String::concat)
 
```
    如果函数返回null映射被删除。如果函数抛出一个（没有）异常，异常会被重新抛出，和当前映射保持不变。
    Specified by:
    
    merge 接口 Map<K,V>
    
    参数
    
    key键，得到的值是相关联的
    
    value -非空值是与存在价值的关键或相关的合并，如果没有存在的价值或空值与密钥相关的，是与密钥相关的
    
    remappingFunction -函数重新计算值如果存在
    
    结果
    
    与指定的键关联的新值，或如果没有值与密钥相关联的空值
  - 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>
    
    结果
    
    这张Map的浅本
    
    另请参见：
    
    Cloneable

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

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

Constructor Detail

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