Hashtable (Java Platform SE 8 )

java.lang.Object
- java.util.Dictionary<K,V>
- - java.util.Hashtable<K,V>

All Implemented Interfaces:

Serializable ， Cloneable ， Map <K，V>

已知直接子类：

Properties ， UIDefaults
```
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable
```
该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键值或值。
为了从散列表成功存储和检索对象，用作键的对象必须实现hashCode方法和equals方法。

Hashtable一个实例有两个影响其性能的参数： 初始容量和负载因子 。容量是哈希表中的桶数， 初始容量只是创建哈希表时的容量。请注意，哈希表是打开的 ：在“哈希冲突”的情况下，单个存储桶存储多个条目，必须依次搜索。 负载因子是在容量自动增加之前允许哈希表得到满足的度量。初始容量和负载因子参数仅仅是实现的暗示。关于何时以及是否调用rehash方法的具体细节是依赖于实现的。

通常，默认负载因子（.75）提供了时间和空间成本之间的良好折衷。更高的值会减少空间开销，但会增加查询条目的时间成本（这反映在大多数Hashtable操作中，包括get和put ）。

初始容量控制了浪费空间与需要rehash操作之间的折中，这是耗时的。没有rehash如果初始容量大于项Hashtable将其负载因子包含除以最大数量永远不会发生的操作。然而，设置初始容量太高可能会浪费空间。

如果将多个条目制作为Hashtable ，则以足够大的容量创建它可能会使条目更有效地插入，以使其根据需要执行自动重新排序以增长表。

此示例创建数字的散列表。它使用数字的名称作为键：
```
   Hashtable<String, Integer> numbers = new Hashtable<String, Integer>(); numbers.put("one", 1); numbers.put("two", 2); numbers.put("three", 3); 
```
要检索一个数字，请使用以下代码：
```
   Integer n = numbers.get("two"); if (n != null) { System.out.println("two = " + n); } 
```
由所有这个类的“集合视图方法”返回的集合的iterator方法返回的迭代器是故障快速的 ：如果Hashtable在迭代器创建之后的任何时间被结构地修改，除了通过迭代器自己的remove方法，迭代器会抛出一个ConcurrentModificationException 。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。 Hashtable的键和元素方法返回的枚举不是故障快速的。

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

从Java 2平台v1.2，这个类被改造为实现Map接口，使其成为成员Java Collections Framework 。与新的集合实现不同， Hashtable是同步的。如果不需要线程安全的实现，建议使用HashMap代替Hashtable 。如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable 。
从以下版本开始：

JDK1.0

另请参见：

Object.equals(java.lang.Object) ， Object.hashCode() ， rehash() ， Collection ， Map ， HashMap ， TreeMap ， Serialized Form

构造方法摘要

构造方法
Constructor and Description
`Hashtable()` 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。
`Hashtable(int initialCapacity)` 构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子（0.75）。
`Hashtable(int initialCapacity, float loadFactor)` 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。
`Hashtable(Map<? extends K,? extends V> t)` 构造一个与给定地图相同的映射的新哈希表。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	Method and Description
`void`	`clear()` 清除此散列表，使其不包含键。
`Object`	`clone()` 创建这个散列表的浅拷贝。
`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`	`contains(Object value)` 测试一些键映射到这个哈希表中的指定值。
`boolean`	`containsKey(Object key)` 测试指定的对象是否在此哈希表中的键。
`boolean`	`containsValue(Object value)` 如果此哈希表将一个或多个键映射到此值，则返回true。
`Enumeration<V>`	`elements()` 返回此散列表中值的枚举。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回此地图中包含的映射的`Set`视图。
`boolean`	`equals(Object o)` 根据Map界面中的定义，将指定的对象与此Map进行比较以相等。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)` 返回到指定键所映射的值，或 `null`如果此映射包含该键的映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回到指定键所映射的值，或 `defaultValue`如果此映射包含该键的映射。
`int`	`hashCode()` 按照Map界面中的定义返回此Map的哈希码值。
`boolean`	`isEmpty()` 测试这个哈希表是否将值映射到值。
`Enumeration<K>`	`keys()` 返回此散列表中键的枚举。
`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)` 将指定的 `key`映射到此 `key` `value`中指定的value。
`void`	`putAll(Map<? extends K,? extends V> t)` 将所有从指定地图的映射复制到此散列表。
`V`	`putIfAbsent(K key, V value)` 如果指定的键尚未与值相关联（或映射到 `null` ）将其与给定值相关联并返回 `null` ，否则返回当前值。
`protected void`	`rehash()` 增加这个散列表的内部重组能力，从而更有效地适应和访问其条目。
`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()` 返回此哈希表中的键数。
`String`	`toString()` 以一组条目的形式返回此 `Hashtable`对象的字符串表示形式，其括在大括号中，并以ASCII字符“ `,` ”（逗号和空格）分隔。
`Collection<V>`	`values()` 返回此地图中包含的值的`Collection`视图。

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

- 构造方法详细信息
  - Hashtable
```
public Hashtable(int initialCapacity,
                 float loadFactor)
```
    构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。
    
    参数
    
    initialCapacity - initialCapacity的初始容量。
    
    loadFactor - loadFactor的负载系数。
    
    异常
    
    IllegalArgumentException - 如果初始容量小于零，或者负载因子是非正性的。
  - Hashtable
```
public Hashtable(int initialCapacity)
```
    构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子（0.75）。
    
    参数
    
    initialCapacity - initialCapacity的初始容量。
    
    异常
    
    IllegalArgumentException - 如果初始容量小于零。
  - Hashtable
```
public Hashtable()
```
    构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。
  - Hashtable
```
public Hashtable(Map<? extends K,? extends V> t)
```
    构造一个与给定地图相同的映射的新哈希表。创建哈希表的初始容量足以保持给定地图中的映射和默认负载因子（0.75）。
    
    参数
    
    t - 其映射将放置在该地图中的地图。
    
    异常
    
    NullPointerException - 如果指定的地图为空。
    
    从以下版本开始：
    
    1.2
- 方法详细信息
  - size
```
public int size()
```
    返回此哈希表中的键数。
    
    Specified by:
    
    size在界面 Map<K,V>
    
    Specified by:
    
    size在类别 Dictionary<K,V>
    
    结果
    
    这个散列表中的键的数量。
  - isEmpty
```
public boolean isEmpty()
```
    测试这个哈希表是否将值映射到值。
    
    Specified by:
    
    isEmpty在界面 Map<K,V>
    
    Specified by:
    
    isEmpty在类别 Dictionary<K,V>
    
    结果
    
    true如果这个哈希表没有将值映射到值; false否则。
  - keys
```
public Enumeration<K> keys()
```
    返回此散列表中键的枚举。
    
    Specified by:
    
    keys在类别 Dictionary<K,V>
    
    结果
    
    这个哈希表中的键的枚举。
    
    另请参见：
    
    Enumeration ， elements() ， keySet() ， Map
  - elements
```
public Enumeration<V> elements()
```
    返回此散列表中值的枚举。对返回的对象使用枚举方法来顺序获取元素。
    
    Specified by:
    
    elements在类别 Dictionary<K,V>
    
    结果
    
    列出这个散列表中的值。
    
    另请参见：
    
    Enumeration ， keys() ， values() ， Map
  - contains
```
public boolean contains(Object value)
```
    测试一些键映射到这个哈希表中的指定值。这个操作比containsKey方法贵。
    注意，此方法是在功能上相同containsValue ，（其是部分Map在集合框架接口）。
    
    参数
    
    value - 要搜索的值
    
    结果
    
    true当且仅当一些键映射到value在由equals方法测定该散列表的参数; false否则。
    
    异常
    
    NullPointerException - 如果值为 null
  - containsValue
```
public boolean containsValue(Object value)
```
    如果此哈希表将一个或多个键映射到此值，则返回true。
    请注意，此方法的功能与contains （早于Map接口）相同。
    
    Specified by:
    
    containsValue在界面 Map<K,V>
    
    参数
    
    value - 要在该散列表中存在的值要进行测试
    
    结果
    
    true如果该地图将一个或多个键映射到指定的值
    
    异常
    
    NullPointerException - 如果值为 null
    
    从以下版本开始：
    
    1.2
  - containsKey
```
public boolean containsKey(Object key)
```
    测试指定的对象是否在此哈希表中的键。
    
    Specified by:
    
    containsKey在界面 Map<K,V>
    
    参数
    
    key - 可能的键
    
    结果
    
    true当且仅当指定的对象是此散列表中的键时，由equals方法确定; false否则。
    
    异常
    
    NullPointerException - 如果键是 null
    
    另请参见：
    
    contains(Object)
  - get
```
public V get(Object key)
```
    返回到指定键所映射的值，或null如果此映射包含该键的映射。
    更正式地，如果这张地图包含从一个键k到一个值v ，这样(key.equals(k)) ，那么这个方法返回v ; 否则返回null 。（最多可以有一个这样的映射。）
    
    Specified by:
    
    get在界面 Map<K,V>
    
    Specified by:
    
    get在类别 Dictionary<K,V>
    
    参数
    
    key - 要返回其关联值的键
    
    结果
    
    指定键映射到的值，如果此映射不包含该键的映射， null
    
    异常
    
    NullPointerException - 如果指定的键为空
    
    另请参见：
    
    put(Object, Object)
  - rehash
```
protected void rehash()
```
    增加这个散列表的内部重组能力，从而更有效地适应和访问其条目。当哈希表中的键数超过此散列表的容量和载入系数时，将自动调用此方法。
  - put
```
public V put(K key,
             V value)
```
    将指定的key映射到此key value中指定的value。钥匙和价值都不能是null 。
    可以通过使用等于原始密钥的密钥来调用get方法来检索该值。
    
    Specified by:
    
    put在界面 Map<K,V>
    
    Specified by:
    
    put在类别 Dictionary<K,V>
    
    参数
    
    key - 哈希表键
    
    value - 值
    
    结果
    
    这个哈希表中指定键的前一个值，如果没有一个， null
    
    异常
    
    NullPointerException - 如果键或值为 null
    
    另请参见：
    
    Object.equals(Object) ， get(Object)
  - remove
```
public V remove(Object key)
```
    从此散列表中删除键（及其对应的值）。如果键不在哈希表中，此方法不执行任何操作。
    
    Specified by:
    
    remove在界面 Map<K,V>
    
    Specified by:
    
    remove在类别 Dictionary<K,V>
    
    参数
    
    key - 需要删除的关键
    
    结果
    
    到钥匙已经被映射在此哈希表，或值 null如果该键没有映射
    
    异常
    
    NullPointerException - 如果键是 null
  - putAll
```
public void putAll(Map<? extends K,? extends V> t)
```
    将所有从指定地图的映射复制到此散列表。这些映射将替换这个散列表对于指定地图中当前的任何键的任何映射。
    
    Specified by:
    
    putAll在界面 Map<K,V>
    
    参数
    
    t - 要存储在此地图中的映射
    
    异常
    
    NullPointerException - 如果指定的地图为空
    
    从以下版本开始：
    
    1.2
  - clear
```
public void clear()
```
    清除此散列表，使其不包含键。
    
    Specified by:
    
    clear在界面 Map<K,V>
  - clone
```
public Object clone()
```
    创建这个散列表的浅拷贝。哈希表本身的所有结构都被复制，但是键和值不被克隆。这是一个相对昂贵的操作。
    
    重写：
    
    clone在类别 Object
    
    结果
    
    哈希表克隆
    
    另请参见：
    
    Cloneable
  - toString
```
public String toString()
```
    以一组条目的形式返回此Hashtable对象的字符串表示形式，其括在大括号中，并以ASCII字符“ , ”（逗号和空格）分隔。每个条目都被渲染为关键字，一个等号=和相关联的元素，其中toString方法用于将键和元素转换为字符串。
    
    重写：
    
    toString在类别 Object
    
    结果
    
    这个散列表的字符串表示形式
  - keySet
```
public Set<K> keySet()
```
    返回此地图中包含的键的Set视图。该集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。该组支持元件移除，即从映射中相应的映射，经由Iterator.remove，Set.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    keySet在界面 Map<K,V>
    
    结果
    
    该地图中包含的键的集合视图
    
    从以下版本开始：
    
    1.2
  - 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>
    
    结果
    
    该地图中包含的映射的集合视图
    
    从以下版本开始：
    
    1.2
  - values
```
public Collection<V> values()
```
    返回此地图中包含的值的Collection视图。集合由地图支持，因此对地图的更改将反映在集合中，反之亦然。如果在集合中的迭代正在进行中修改映射（除了通过迭代器自己的remove操作），迭代的结果是未定义的。该collection支持元素移除，即从映射中相应的映射，经由Iterator.remove，Collection.remove，removeAll，retainAll和clear操作。它不支持add或addAll操作。
    
    Specified by:
    
    values在界面 Map<K,V>
    
    结果
    
    该地图中包含的值的集合视图
    
    从以下版本开始：
    
    1.2
  - equals
```
public boolean equals(Object o)
```
    根据Map界面中的定义，将指定的对象与此Map进行比较以相等。
    
    Specified by:
    
    equals在界面 Map<K,V>
    
    重写：
    
    equals在类别 Object
    
    参数
    
    o - 要与此散列表相等的对象进行比较
    
    结果
    
    如果指定的Object等于此Map，则为true
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Map.equals(Object)
  - hashCode
```
public int hashCode()
```
    按照Map界面中的定义返回此Map的哈希码值。
    
    Specified by:
    
    hashCode在界面 Map<K,V>
    
    重写：
    
    hashCode在 Object
    
    结果
    
    该对象的哈希码值。
    
    从以下版本开始：
    
    1.2
    
    另请参见：
    
    Map.hashCode()
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    说明从界面： Map复制
    
    返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。
    
    Specified by:
    
    getOrDefault在界面 Map<K,V>
    
    参数
    
    key - 要返回其关联值的键
    
    defaultValue - 键的默认映射
    
    结果
    
    指定键映射到的值，如果此映射不包含键的映射， defaultValue
  - 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 - 应用于每个条目的功能
  - 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 ，如果实现支持空值）。
  - 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

Class Hashtable<K,V>

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

构造方法详细信息

Hashtable

Hashtable

Hashtable

Hashtable

方法详细信息

size

isEmpty

keys

elements

contains

containsValue

containsKey

get

rehash

put

remove

putAll

clear

clone

toString

keySet

entrySet

values

equals

hashCode

getOrDefault

forEach

replaceAll

putIfAbsent

remove

replace

replace

computeIfAbsent

computeIfPresent

compute

merge