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

参数类型

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

V - 映射值的类型

实现的所有接口

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操作需求之间的权衡，这是非常耗时的。如果初始容量大于Hashtable将包含的最大条目数除以其加载因子，则将不会发生rehash操作。但是，将初始容量设置得太高会浪费空间。

如果要在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的keys和elements方法返回的枚举不是快速失败的; 如果在创建枚举后的任何时候对Hashtable进行结构修改，则枚举的结果是未定义的。

请注意，迭代器的快速失败行为无法得到保证，因为一般来说，在存在不同步的并发修改时，不可能做出任何硬性保证。失败快速迭代器以尽力而为的方式抛出ConcurrentModificationException 。因此，编写依赖于此异常的程序以确保其正确性是错误的： 迭代器的快速失败行为应该仅用于检测错误。

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

1.0

另请参见：

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

构造方法摘要

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

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`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)`	如果指定键的值存在且为非null，则尝试在给定键及其当前映射值的情况下计算新映射。
`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接口中的定义，将指定的Object与此Map进行相等性比较。
`V`	`get(Object key)`	返回指定键映射到的值，如果此映射不包含键的映射，则返回 `null` 。
`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`映射到此哈希表中的指定 `value` 。
`void`	`putAll(Map<? extends K,? extends V> t)`	将指定映射中的所有映射复制到此哈希表。
`protected void`	`rehash()`	增加此哈希表的容量并在内部重新组织，以便更有效地容纳和访问其条目。
`V`	`remove(Object key)`	从此哈希表中删除键（及其对应的值）。
`int`	`size()`	返回此哈希表中的键数。
`String`	`toString()`	以一组条目的形式返回此 `Hashtable`对象的字符串表示形式，用大括号括起，并用ASCII字符“ `,` ”（逗号和空格）分隔。
`Collection<V>`	`values()`	返回此映射中包含的值的`Collection`视图。

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

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

- 构造方法详细信息
  - Hashtable
```
public Hashtable(int initialCapacity,                 float loadFactor)
```
    使用指定的初始容量和指定的加载因子构造一个新的空哈希表。
    
    参数
    
    initialCapacity - 哈希表的初始容量。
    
    loadFactor - 哈希表的加载因子。
    
    异常
    
    IllegalArgumentException - 如果初始容量小于零，或者负载因子是非正数。
  - Hashtable
```
public Hashtable(int initialCapacity)
```
    使用指定的初始容量和默认加载因子（0.75）构造一个新的空哈希表。
    
    参数
    
    initialCapacity - 哈希表的初始容量。
    
    异常
    
    IllegalArgumentException - 如果初始容量小于零。
  - Hashtable
```
public Hashtable()
```
    使用默认初始容量（11）和加载因子（0.75）构造一个新的空哈希表。
  - Hashtable
```
public Hashtable(Map<? extends K,? extends V> t)
```
    构造一个新的哈希表，其具有与给定Map相同的映射。创建哈希表的初始容量足以容纳给定Map中的映射和默认加载因子（0.75）。
    
    参数
    
    t - t映射放在此映射中的映射。
    
    异常
    
    NullPointerException - 如果指定的映射为null。
    
    从以下版本开始：
    
    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()
```
    返回此哈希表中键的枚举。在返回的对象上使用Enumeration方法按顺序获取密钥。如果在枚举键的同时对哈希表进行结构修改，那么枚举的结果是未定义的。
    
    Specified by:
    
    keys类 Dictionary<K,V>
    
    结果
    
    此哈希表中的键的枚举。
    
    另请参见：
    
    Enumeration ， elements() ， keySet() ， Map
  - elements
```
public Enumeration<V> elements()
```
    返回此哈希表中值的枚举。在返回的对象上使用Enumeration方法按顺序获取元素。如果在枚举值的同时对哈希表进行结构修改，则枚举的结果是未定义的。
    
    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映射到此哈希表中的指定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 - 如果指定的映射为null
    
    从以下版本开始：
    
    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>
    
    结果
    
    此映射中包含的映射的set视图
    
    从以下版本开始：
    
    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接口中的定义，将指定的Object与此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()
  - 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则null 。当组合密钥的多个映射值时，该方法可以是有用的。例如，要创建或附加String msg到值映射：
    map.merge(key, msg, String::concat)
    
    如果重映射函数返回null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并保持当前映射不变。
    
    重映射功能不应在计算期间修改此映射。
    
    如果重映射函数在计算期间修改了该映射，则该方法将在尽力而为的基础上抛出ConcurrentModificationException 。
    Specified by:
    
    merge在界面 Map<K,V>
    
    参数
    
    key - 与结果值关联的键
    
    value - 要与与键关联的现有值合并的非空值，或者，如果没有现有值或与键关联的空值，则与键关联
    
    remappingFunction - 重新计算值的重新映射函数（如果存在）
    
    结果
    
    与指定键关联的新值，如果没有值与键关联，则返回null
    
    异常
    
    ConcurrentModificationException - 如果检测到重映射功能修改了此映射

Class Hashtable<K,​V>

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

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

构造方法详细信息

Hashtable

Hashtable

Hashtable

Hashtable

方法详细信息

size

isEmpty

keys

elements

contains

containsValue

containsKey

get

rehash

put

remove

putAll

clear

clone

toString

keySet

entrySet

values

equals

hashCode

computeIfAbsent

computeIfPresent

compute

merge

Class Hashtable<K,V>