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对象可以作为key或值。
成功地向哈希表中存储或检索对象，作为key的对象必须实现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方法返回这个类的所有的“集合视图的方法“快速失败：如果哈希表结构修改后迭代器创建的任何时间，以任何方式除了通过迭代器的remove方法，迭代器将抛出一个ConcurrentModificationException。因此，在遇到同步修改，迭代器不能快速、干净，而不是冒着任意的，非在将来一个不确定的时间确定的行为。枚举返回Hashtable的键和元素的方法不能快速失败。

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

作为java 2平台V1.2，这类改造实施Map接口，使得它的 Java Collections Framework成员。不像新采集的实现，Hashtable是同步的。如果一个线程安全的实现是不需要的，建议在地方Hashtable使用HashMap。如果一个线程安全的高度并行执行的需要，那么建议在地方Hashtable使用ConcurrentHashMap。
从以下版本开始：

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)` 构建了一种新的哈希表作为给定Map相同的映射。

方法摘要

所有方法接口方法具体的方法
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`），尝试使用给定的映射功能，进入到这个Map除非 `null`计算其价值。
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果指定键的值是存在和非空的，尝试计算一个新的映射，给出了键和它当前的映射值。
`boolean`	`contains(Object value)` 测试是否有key映射到哈希表中指定的值。
`boolean`	`containsKey(Object key)` 测试指定对象是否是一个哈希表的键。
`boolean`	`containsValue(Object value)` 如果哈希表映射到一个或多个键的值返回true。
`Enumeration<V>`	`elements()` 返回哈希表中的值的枚举。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回一个 `Set`映射的视图包含在这个Map。
`boolean`	`equals(Object o)` 将指定的对象与此映射的相等性进行比较，按照Map接口中的定义。
`void`	`forEach(BiConsumer<? super K,? super V> action)` 在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。
`V`	`get(Object key)` 返回指定的键映射的值，或 `null`如果这个Map不包含的键映射。
`V`	`getOrDefault(Object key, V defaultValue)` 返回指定的键映射的值，或 `defaultValue`如果这个Map不包含的键映射。
`int`	`hashCode()` 返回此映射的哈希代码值，按Map接口的定义。
`boolean`	`isEmpty()` 如果没有键值的哈希表映射。
`Enumeration<K>`	`keys()` 返回哈希表中的键枚举。
`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)` 映射指定的 `key`到哈希表中指定的 `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`的价值观包含在这个Map。

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

- Constructor Detail
  - 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的映射被放置在这个Map的Map。
    
    异常
    
    NullPointerException -如果指定的Map是空的。
    
    从以下版本开始：
    
    一点二
- 方法详细信息
  - 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)
```
    测试是否有key映射到哈希表中指定的值。该操作比 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
    
    从以下版本开始：
    
    一点二
  - 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如果这个Map不包含的键映射。
    更正式地说，如果这个图中包含了从关键k到价值v这样(key.equals(k))映射，那么这个方法返回v；否则返回null。（最多可以有一个这样的映射。）
    
    Specified by:
    
    get 接口 Map<K,V>
    
    Specified by:
    
    get 方法重写，继承类 Dictionary<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    结果
    
    值，指定的键映射，或 null如果这个Map不包含的键映射
    
    异常
    
    NullPointerException -如果指定的键是空的
    
    另请参见：
    
    put(Object, Object)
  - rehash
```
protected void rehash()
```
    增加的容量和内部调整哈希表，为了更有效地容纳和访问项。这种方法被称为自动时，哈希表中的键的数目超过了哈希表的容量和加载因子。
  - put
```
public V put(K key,
             V value)
```
    映射指定的 key到哈希表中指定的 value。key和值可以 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)
```
    从指定的映射到哈希表映射的所有副本。这些映射将取代任何映射哈希表有任何的键目前在指定的Map。
    
    Specified by:
    
    putAll 接口 Map<K,V>
    
    参数
    
    t映射被存储在这个Map
    
    异常
    
    NullPointerException -如果指定的Map是空的
    
    从以下版本开始：
    
    一点二
  - clear
```
public void clear()
```
    清除此哈希表以便它包含没有钥匙。
    
    Specified by:
    
    clear 接口 Map<K,V>
  - clone
```
public Object clone()
```
    创建一个哈希表的浅拷贝。哈希表自身的结构被复制，但键和值不克隆。这是一个相对昂贵的操作。
    
    重写：
    
    clone 方法重写，继承类 Object
    
    结果
    
    Hashtable的克隆
    
    另请参见：
    
    Cloneable
  - toString
```
public String toString()
```
    返回一组项的形式，这 Hashtable对象的字符串表示，括在括号和分隔的ASCII字符“ , ”（逗号和空格）。每一项表示为关键，等号 =，和相关的元素，在 toString法将key和元素转换成字符串。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    一个哈希表的字符串表示形式
  - 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>
    
    结果
    
    在这个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>
    
    结果
    
    映射中包含的映射的一个集合视图
    
    从以下版本开始：
    
    一点二
  - 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>
    
    结果
    
    一个包含在这个Map中的值的集合视图
    
    从以下版本开始：
    
    一点二
  - equals
```
public boolean equals(Object o)
```
    将指定的对象与此映射的相等性进行比较，按照Map接口中的定义。
    
    Specified by:
    
    equals 接口 Map<K,V>
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    o对象是比较平等与哈希表
    
    结果
    
    如果指定的对象与此映射相等，则为
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    Map.equals(Object)
  - hashCode
```
public int hashCode()
```
    返回此映射的哈希代码值，按Map接口的定义。
    
    Specified by:
    
    hashCode 接口 Map<K,V>
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    此对象的哈希代码值。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    Map.hashCode()
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    从接口复制的描述： Map
    
    返回指定的键映射的值，或 defaultValue如果这个Map不包含的键映射。
    
    Specified by:
    
    getOrDefault 接口 Map<K,V>
    
    参数
    
    key -关键的相关值被返回
    
    defaultValue -键的默认映射
    
    结果
    
    值，指定的键映射，或 defaultValue如果这个Map不包含的键映射
  - 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如果没有键映射。（一 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 -函数重新计算值如果存在
    
    结果
    
    与指定的键关联的新值，或如果没有值与密钥相关联的空值

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 Hashtable<K,V>

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

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