Module java.base

Package java.util

Class Hashtable<K,V>

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的一个实例有两个影响其性能的参数: 初始容量和负载因子。 容量是哈希表中的桶数，而初始容量只是哈希表创建时的容量。请注意，哈希表是开放式的: 在“哈希冲突”情况下，单个桶存储多个条目，必须按顺序搜索。 负载因子是哈希表允许达到的填充程度的度量。初始容量和负载因子参数仅仅是对实现的提示。何时以及是否调用重新哈希方法的确切细节取决于实现。

通常，默认负载因子（.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集合框架的成员。与新的集合实现不同，Hashtable是同步的。如果不需要线程安全的实现，则建议使用Hashtable的替代品HashMap。如果需要线程安全的高并发实现，则建议使用Hashtable的替代品ConcurrentHashMap。

自版本:

1.0

参见:

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

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	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进行比较以确定是否相等。
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视图。

Methods declared in class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.Map

forEach, getOrDefault, putIfAbsent, remove, replace, replace, replaceAll

Constructor Details

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 - 要将其映射放入此映射中的映射。

抛出:

NullPointerException - 如果指定的映射为null。

自版本:

1.2

Method Details

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>中

返回值：

此哈希表中键的枚举。

另请参阅：

• Enumeration
• elements()
• keySet()
• Map

elements

             public Enumeration<V> elements()
            

返回此哈希表中值的枚举。使用返回对象上的枚举方法按顺序获取元素。如果在枚举值时对哈希表进行结构修改，则枚举结果是未定义的。

指定者：

elements 在类 Dictionary<K,V>中

返回值：

此哈希表中值的枚举。

另请参阅：

• Enumeration
• keys()
• values()
• Map

contains

             public boolean contains(Object value)
            

测试某个键是否映射到此哈希表中的指定值。此操作比containsKey方法更昂贵。

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

参数：

value - 要搜索的值

返回值：

如果某个键根据equals方法映射到此哈希表中的value参数，则返回true；否则返回false。

抛出：

NullPointerException - 如果值为null

containsValue

             public boolean containsValue(Object value)
            

如果此哈希表将一个或多个键映射到此值，则返回true。

请注意，此方法在功能上与contains相同（它是Map接口之前的方法）。

指定者：

containsValue 在接口 Map<K,V>中

参数：

value - 要测试其在此哈希表中的存在性的值

返回值：

如果此映射将一个或多个键映射到指定值，则返回true

抛出：

NullPointerException - 如果值为null

自：

1.2

containsKey

             public boolean containsKey(Object key)
            

测试指定对象是否为此哈希表中的键。

指定者：

containsKey 在接口 Map<K,V>中

参数：

key - 可能的键

返回值：

如果指定对象是此哈希表中的键（根据equals方法确定），则返回true；否则返回false。

抛出：

NullPointerException - 如果键为null

另请参阅：

• contains(Object)

get

             public V get(Object key)
            

返回指定键映射到的值，如果此映射不包含键的映射关系，则返回null。

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

指定者：

get 在接口 Map<K,V>中

指定者：

get 在类 Dictionary<K,V>中

参数：

key - 要返回其关联值的键

返回值：

指定键映射到的值，如果此映射不包含键的映射关系，则返回null

抛出：

NullPointerException - 如果指定键为null

另请参阅：

• put(Object, Object)

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

另请参阅：

• Object.equals(Object)
• get(Object)

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)
            

将指定映射中的所有映射复制到此哈希表中。这些映射将替换此哈希表当前对于指定映射中任何键的所有映射。

指定者:

putAll 在接口 Map<K,V>中

参数:

t - 要存储在此映射中的映射

抛出:

NullPointerException - 如果指定映射为null

自1.2版本起:

1.2

clear

             public void clear()
            

清除此哈希表，使其不包含任何键。

指定者:

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操作。

指定者:

keySet 在接口 Map<K,V>中

返回值:

包含在此映射中的键的集合视图

自1.2版本起:

1.2

entrySet

             public Set<Map.Entry<K,V>> entrySet()
            

返回此映射中包含的映射的Set视图。该集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了映射（除非通过迭代器自身的remove操作，或通过迭代器返回的映射条目上的setValue操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作从映射中移除相应的映射。它不支持add或addAll操作。

指定者:

entrySet 在接口 Map<K,V>中

返回值:

包含在此映射中的映射的集合视图

自1.2版本起:

1.2

values

             public Collection<V> values()
            

返回此映射中包含的值的Collection视图。该集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改了映射（除非通过迭代器自身的remove操作），则迭代的结果是未定义的。该集合支持元素移除，通过Iterator.remove、Collection.remove、removeAll、retainAll和clear操作从映射中移除相应的映射。它不支持add或addAll操作。

指定者:

values 在接口 Map<K,V>中

返回值:

包含在此映射中的值的集合视图

自1.2版本起:

1.2

equals

             public boolean equals(Object o)
            

根据Map接口中的定义，将指定的对象与此Map进行比较以确定是否相等。

指定者:

equals 在接口 Map<K,V>中

覆盖:

equals 在类 Object中

参数:

o - 用于与此哈希表比较相等性的对象

返回值:

如果指定的对象等于此Map，则返回true

自1.2版本起:

1.2

参见:

• Map.equals(Object)

hashCode

             public int hashCode()
            

根据Map接口中的定义，返回此Map的哈希码值。

指定者:

hashCode 在接口 Map<K,V>中

覆盖:

hashCode 在类 Object中

返回值:

此对象的哈希码值。

自1.2版本起:

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。

指定者:

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

指定者:

computeIfPresent 在接口 Map<K,V>中

参数:

key - 要关联指定值的键

remappingFunction - 用于计算值的重新映射函数

返回值:

与指定键关联的新值，如果没有则返回null

抛出:

ConcurrentModificationException - 如果检测到重新映射函数修改了此映射

compute

             public V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
            

尝试为指定键及其当前映射值（如果没有当前映射值则为null）计算映射。例如，要创建或追加String msg到值映射中：

 
 map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))

（对于此类目的，通常更简单的方法是使用merge()方法。）

如果重新映射函数返回null，则移除映射（如果最初不存在，则保持缺失）。如果重新映射函数本身抛出（未检查的）异常，则重新抛出异常，并且当前映射保持不变。

在计算过程中，重新映射函数不应修改此映射。

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

指定者:

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

指定者:

merge 在接口 Map<K,V>中

参数:

key - 要关联结果值的键

value - 与键关联的现有值合并的非null值，如果与键关联的现有值为null或没有关联值，则与键关联

remappingFunction - 重新计算值的重新映射函数（如果存在）

返回值:

与指定键关联的新值，如果与键关联的值为null则返回null

抛出:

ConcurrentModificationException - 如果检测到重新映射函数修改了此映射