模块 java.base
包 java.util

类 Hashtable<K,V>

java.lang.Object
java.util.Dictionary <K,V>
java.util.Hashtable<K,V>
类型参数：
K - 此map维护的键类型
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 的实例有两个影响其性能的参数：初始容量和负载系数.这capacity是的数量水桶在哈希表中，并且初始容量只是创建哈希表时的容量。注意哈希表是打开：在“哈希冲突”的情况下，单个桶存储多个条目，必须顺序搜索。这负载系数是哈希表在其容量自动增加之前允许达到多满的量度。初始容量和负载因子参数只是对实现的提示。关于何时以及是否调用 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方法返回的迭代器是fail-fast：如果在创建迭代器后的任何时间以任何方式修改哈希表的结构，除了通过迭代器自己的remove方法，迭代器将抛出一个 ConcurrentModificationException 。因此，面对并发修改，迭代器会快速干净地失败，而不是冒着在未来不确定的时间出现任意的、不确定的行为的风险。 Hashtable 的 keys 和 elements 方法返回的 Enumerations 是 not fail-fast；如果 Hashtable 在创建枚举后的任何时候在结构上被修改，那么枚举的结果是不确定的。

请注意，无法保证迭代器的快速失败行为，因为一般来说，在存在非同步并发修改的情况下不可能做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的正确性的程序是错误的：迭代器的快速失败行为应该只用于检测错误。

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

自从：
1.0
参见：

  • 构造方法总结

    构造方法
    构造方法
    描述
    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 ），则尝试使用给定的映射函数计算其值并将其输入此map，除非 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()
    返回此map中包含的映射的 Set 视图。
    boolean
    equals(Object o)
    根据 Map 接口中的定义，比较指定的 Object 与此 Map 是否相等。
    V
    get(Object key)
    返回指定键映射到的值，如果此map不包含键的映射，则返回 null。
    int
    hashCode()
    根据 Map 接口中的定义返回此 Map 的哈希码值。
    boolean
    isEmpty()
    测试此哈希表是否没有将键映射到值。
    Enumeration<K>
    keys()
    返回此哈希表中键的枚举。
    Set<K>
    keySet()
    返回此map中包含的键的 Set 视图。
    V
    merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
    如果指定的键尚未与值关联或与 null 关联，则将其与给定的非 null 值关联。
    V
    put(K key, V value)
    将指定的 key 映射到此哈希表中指定的 value。
    void
    putAll(Map<? extends K,? extends V> t)
    将指定map中的所有值复制到此哈希表。
    protected void
    rehash()
    增加哈希表的容量并在内部重组该哈希表，以便更有效地容纳和访问其条目。
    V
    remove(Object key)
    从此哈希表中删除键（及其对应的值）。
    int
    size()
    返回此哈希表中的键数。
    String
    toString()
    以一组条目的形式返回此 Hashtable 对象的字符串表示形式，括在大括号中并由 ASCII 字符“ , ”（逗号和空格）分隔。
    Collection<V>
    values()
    返回此map中包含的值的 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 - 其映射要放置在此map中的map。
      抛出：
      NullPointerException - 如果指定的map为空。
      自从：
      1.2

  • 方法详情

    • size

      public int size()
      返回此哈希表中的键数。
      指定者：
      size 在接口 Map<K,V> 中
      指定者：
      size 在类 Dictionary<K,V> 中
      返回：
      此哈希表中的键数。

    • isEmpty

      public boolean isEmpty()
      测试此哈希表是否没有将键映射到值。
      指定者：
      isEmpty 在接口 Map<K,V> 中
      指定者：
      isEmpty 在类 Dictionary<K,V> 中
      返回：
      true 如果此哈希表没有将键映射到值； false否则。

    • keys

      public Enumeration <K > keys()
      返回此哈希表中键的枚举。在返回的对象上使用枚举方法按顺序获取键。如果在对键进行枚举时对哈希表进行了结构修改，则枚举的结果是未定义的。
      指定者：
      keys 在类 Dictionary<K,V> 中
      返回：
      此哈希表中键的枚举。
      参见：

    • elements

      public Enumeration <V > elements()
      返回此哈希表中值的枚举。在返回的对象上使用 Enumeration 方法按顺序获取元素。如果在枚举值时对哈希表进行了结构修改，则枚举的结果是未定义的。
      指定者：
      elements 在类 Dictionary<K,V> 中
      返回：
      此哈希表中值的枚举。
      参见：

    • contains

      public boolean contains(Object  value)
      测试某些键是否映射到此哈希表中的指定值。此操作比containsKey 方法更昂贵。

      请注意，此方法在功能上与 containsValue 相同（它是集合框架中 Map 接口的一部分）。

      参数：
      value - 要搜索的值
      返回：
      true 当且仅当某些键映射到由 equals 方法确定的此哈希表中的 value 参数时； false否则。
      抛出：
      NullPointerException - 如果值为 null

    • containsValue

      public boolean containsValue(Object  value)
      如果此哈希表将一个或多个键映射到此值，则返回 true。

      请注意，此方法在功能上与 contains （早于 Map 接口）相同。

      指定者：
      containsValue 在接口 Map<K,V> 中
      参数：
      value - 要测试其在此哈希表中是否存在的值
      返回：
      true 如果此map将一个或多个键映射到指定值
      抛出：
      NullPointerException - 如果值为 null
      自从：
      1.2

    • containsKey

      public boolean containsKey(Object  key)
      测试指定对象是否是此哈希表中的键。
      指定者：
      containsKey 在接口 Map<K,V> 中
      参数：
      key - 可能的关键
      返回：
      true 当且仅当指定对象是此哈希表中的键时，由 equals 方法确定； false否则。
      抛出：
      NullPointerException - 如果密钥是 null
      参见：

    • get

      public V  get(Object  key)
      返回指定键映射到的值，如果此map不包含键的映射，则返回 null。

      更正式地说，如果此map包含从键 k 到值 v 的映射，使得 (key.equals(k)) ，则此方法返回 v ；否则返回 null 。 （最多可以有一个这样的映射。）

      指定者：
      get 在接口 Map<K,V> 中
      指定者：
      get 在类 Dictionary<K,V> 中
      参数：
      key - 要返回其关联值的键
      返回：
      指定键映射到的值，如果此map不包含键的映射，则返回 null
      抛出：
      NullPointerException - 如果指定的键为空
      参见：

    • rehash

      protected void rehash()
      增加哈希表的容量并在内部重组该哈希表，以便更有效地容纳和访问其条目。当哈希表中的键数超过此哈希表的容量和负载因子时，将自动调用此方法。

    • put

      public V  put(K  key, V  value)
      将指定的 key 映射到此哈希表中指定的 value。键和值都不能是 null 。

      可以通过使用与原始键相同的键调用 get 方法来检索该值。

      指定者：
      put 在接口 Map<K,V> 中
      指定者：
      put 在类 Dictionary<K,V> 中
      参数：
      key - 哈希表键
      value - 值
      返回：
      此哈希表中指定键的先前值，如果没有，则返回 null
      抛出：
      NullPointerException - 如果键或值是 null
      参见：

    • remove

      public V  remove(Object  key)
      从此哈希表中删除键（及其对应的值）。如果键不在哈希表中，则此方法不执行任何操作。
      指定者：
      remove 在接口 Map<K,V> 中
      指定者：
      remove 在类 Dictionary<K,V> 中
      参数：
      key - 需要删除的密钥
      返回：
      键在此哈希表中映射到的值，如果键没有映射，则为 null
      抛出：
      NullPointerException - 如果密钥是 null

    • putAll

      public void putAll(Map <? extends K ,? extends V > t)
      将指定map中的所有映射复制到此哈希表。这些映射将替换此哈希表对指定map中当前任何键的任何映射。
      指定者：
      putAll 在接口 Map<K,V> 中
      参数：
      t - 要存储在此map中的映射
      抛出：
      NullPointerException - 如果指定的map为空
      自从：
      1.2

    • clear

      public void clear()
      清除此哈希表，使其不包含键。
      指定者：
      clear 在接口 Map<K,V> 中

    • clone

      public Object  clone()
      创建此哈希表的浅表副本。哈希表本身的所有结构都被复制，但键和值没有被克隆。这是一个相对昂贵的操作。
      重写：
      clone 在类 Object 中
      返回：
      哈希表的克隆
      参见：

    • toString

      public String  toString()
      以一组条目的形式返回此 Hashtable 对象的字符串表示形式，括在大括号中并由 ASCII 字符“ , ”（逗号和空格）分隔。每个条目都呈现为键、等号 = 和关联的元素，其中 toString 方法用于将键和元素转换为字符串。
      重写：
      toString 在类 Object 中
      返回：
      此哈希表的字符串表示形式

    • keySet

      public Set <K > keySet()
      返回此map中包含的键的 Set 视图。该集合由map支持，因此对map的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改map（除了通过迭代器自己的 remove 操作），迭代的结果是不确定的。该集合支持元素删除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。它不支持 add 或 addAll 操作。
      指定者：
      keySet 在接口 Map<K,V> 中
      返回：
      此map中包含的键的集合视图
      自从：
      1.2

    • entrySet

      public Set <Map.Entry <K ,V >> entrySet()
      返回此map中包含的映射的 Set 视图。该集合由map支持，因此对map的更改会反映在集合中，反之亦然。如果在对集合进行迭代时映射被修改（除了通过迭代器自己的 remove 操作，或通过迭代器返回的映射条目上的 setValue 操作），迭代的结果是未定义的。该集合支持元素移除，即通过 Iterator.remove 、 Set.remove 、 removeAll 、 retainAll 和 clear 操作从map中移除相应的映射。它不支持 add 或 addAll 操作。
      指定者：
      entrySet 在接口 Map<K,V> 中
      返回：
      此map中包含的映射的集合视图
      自从：
      1.2

    • values

      public Collection <V > values()
      返回此map中包含的值的 Collection 视图。集合由map支持，因此对map的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改map（除了通过迭代器自己的 remove 操作），迭代的结果是不确定的。该集合支持元素删除，即通过 Iterator.remove 、 Collection.remove 、 removeAll 、 retainAll 和 clear 操作从map中删除相应的映射。它不支持 add 或 addAll 操作。
      指定者：
      values 在接口 Map<K,V> 中
      返回：
      此map中包含的值的集合视图
      自从：
      1.2

    • equals

      public boolean equals(Object  o)
      根据 Map 接口中的定义，比较指定的 Object 与此 Map 是否相等。
      指定者：
      equals 在接口 Map<K,V> 中
      重写：
      equals 在类 Object 中
      参数：
      o - 要与此哈希表进行相等比较的对象
      返回：
      如果指定的 Object 等于此 Map，则为 true
      自从：
      1.2
      参见：

    • hashCode

      public int hashCode()
      根据 Map 接口中的定义返回此 Map 的哈希码值。
      指定者：
      hashCode 在接口 Map<K,V> 中
      重写：
      hashCode 在类 Object 中
      返回：
      此对象的哈希码值。
      自从：
      1.2
      参见：

    • computeIfAbsent

      public V  computeIfAbsent(K  key, Function <? super K ,? extends V > mappingFunction)
      如果指定的键尚未与值关联（或映射到 null ），则尝试使用给定的映射函数计算其值并将其输入此map，除非 null 。

      如果map函数返回 null ，则不记录任何映射。如果map函数本身抛出（未经检查的）异常，则重新抛出异常，并且不记录任何映射。最常见的用法是构造一个新对象作为初始映射值或记忆结果，如下所示：

       
 map.computeIfAbsent(key, k -> new Value(f(k)));

      或者实现多值映射 Map<K,Collection<V>> ，支持每个键多个值：

       
 map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);

      映射函数不应在计算期间修改此map。

      如果map函数在计算期间修改了此map，则此方法将尽最大努力抛出 ConcurrentModificationException 。

      指定者：
      computeIfAbsent 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      mappingFunction - 计算值的映射函数
      返回：
      与指定键关联的当前（现有或计算）值，如果计算值为 null，则为 null
      抛出：
      ConcurrentModificationException - 如果检测到映射函数修改了这个map

    • computeIfPresent

      public V  computeIfPresent(K  key, BiFunction <? super K ,? super V ,? extends V > remappingFunction)
      如果指定键的值存在且非空，则尝试在给定键及其当前映射值的情况下计算新映射。

      如果重映射函数返回 null ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      如果重新映射函数在计算期间修改了此map，则此方法将尽最大努力抛出 ConcurrentModificationException 。

      指定者：
      computeIfPresent 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      remappingFunction - 计算值的重映射函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      ConcurrentModificationException - 如果检测到重映射函数修改了这个map

    • 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 ，则映射将被删除（或者如果最初不存在则保持不存在）。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      如果重新映射函数在计算期间修改了此map，则此方法将尽最大努力抛出 ConcurrentModificationException 。

      指定者：
      compute 在接口 Map<K,V> 中
      参数：
      key - 与指定值关联的键
      remappingFunction - 计算值的重映射函数
      返回：
      与指定键关联的新值，如果没有则为 null
      抛出：
      ConcurrentModificationException - 如果检测到重映射函数修改了这个map

    • 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 ，则删除映射。如果重映射函数本身抛出（未经检查的）异常，则重新抛出异常，并且当前映射保持不变。

      重新映射函数不应在计算期间修改此map。

      如果重新映射函数在计算期间修改了此map，则此方法将尽最大努力抛出 ConcurrentModificationException 。

      指定者：
      merge 在接口 Map<K,V> 中
      参数：
      key - 与结果值关联的键
      value - 要与键关联的现有值合并的非空值，或者，如果没有现有值或空值与键关联，则与键关联
      remappingFunction - 重新映射函数以重新计算值（如果存在）
      返回：
      与指定键关联的新值，如果没有值与该键关联，则返回 null
      抛出：
      ConcurrentModificationException - 如果检测到重映射函数修改了这个map