这个 哈希表 类实现一个哈希表，该哈希表将键映射到值。任何非空对象都可以用作键或值。要成功地从哈希表中存储和检索对象，用作键的对象必须实现hashCode方法和equals方法。
null
哈希表的特性
- 它类似于HashMap，但是同步的。
- 哈希表在哈希表中存储键/值对。
- 在哈希表中，我们指定一个用作键的对象，以及要与该键关联的值。然后对键进行散列，得到的散列码被用作索引，该值存储在表中。
- Hashtable类的初始默认容量为11，而loadFactor为0.75。
- HashMap不提供任何枚举，而Hashtable提供不失败快速枚举。
宣言：
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable
类型参数：
- K –此地图维护的钥匙类型
- 五、 –映射值的类型
哈希表的层次结构
哈希表实现 可序列化 , 可克隆 , Map
施工人员：
为了创建哈希表，我们需要从 JAVAutil。哈希表 .我们可以通过多种方式创建哈希表。
1.哈希表（）： 这将创建一个空哈希表，默认负载因子为0.75，初始容量为11。
Hashtable
ht=新的Hashtable （）；
JAVA
// Java program to demonstrate // adding elements to Hashtable import java.io.*; import java.util.*; class AddElementsToHashtable { public static void main(String args[]) { // No need to mention the // Generic type twice Hashtable<Integer, String> ht1 = new Hashtable<>(); // Initialization of a Hashtable // using Generics Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>(); // Inserting the Elements // using put() method ht1.put( 1 , "one" ); ht1.put( 2 , "two" ); ht1.put( 3 , "three" ); ht2.put( 4 , "four" ); ht2.put( 5 , "five" ); ht2.put( 6 , "six" ); // Print mappings to the console System.out.println( "Mappings of ht1 : " + ht1); System.out.println( "Mappings of ht2 : " + ht2); } } |
输出
Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {6=six, 5=five, 4=four}
2.哈希表（int initialCapacity）： 这将创建一个哈希表，其初始大小由initialCapacity指定，默认负载系数为0.75。
Hashtable
ht=新的Hashtable （int initialCapacity）；
JAVA
// Java program to demonstrate // adding elements to Hashtable import java.io.*; import java.util.*; class AddElementsToHashtable { public static void main(String args[]) { // No need to mention the // Generic type twice Hashtable<Integer, String> ht1 = new Hashtable<>( 4 ); // Initialization of a Hashtable // using Generics Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>( 2 ); // Inserting the Elements // using put() method ht1.put( 1 , "one" ); ht1.put( 2 , "two" ); ht1.put( 3 , "three" ); ht2.put( 4 , "four" ); ht2.put( 5 , "five" ); ht2.put( 6 , "six" ); // Print mappings to the console System.out.println( "Mappings of ht1 : " + ht1); System.out.println( "Mappings of ht2 : " + ht2); } } |
输出
Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {4=four, 6=six, 5=five}
3.哈希表（int-size，float-fillRatio）： 这个版本创建一个哈希表，其初始大小由size指定，填充率由fillRatio指定。填充率：基本上，它决定哈希表在向上调整大小之前的填充程度，其值介于0.0到1.0之间。
Hashtable
ht=新的Hashtable （int-size，float-fillRatio）；
JAVA
// Java program to demonstrate // adding elements to Hashtable import java.io.*; import java.util.*; class AddElementsToHashtable { public static void main(String args[]) { // No need to mention the // Generic type twice Hashtable<Integer, String> ht1 = new Hashtable<>( 4 , 0 .75f); // Initialization of a Hashtable // using Generics Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>( 3 , 0 .5f); // Inserting the Elements // using put() method ht1.put( 1 , "one" ); ht1.put( 2 , "two" ); ht1.put( 3 , "three" ); ht2.put( 4 , "four" ); ht2.put( 5 , "five" ); ht2.put( 6 , "six" ); // Print mappings to the console System.out.println( "Mappings of ht1 : " + ht1); System.out.println( "Mappings of ht2 : " + ht2); } } |
输出
Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {6=six, 5=five, 4=four}
4.哈希表（映射m）： 这将创建一个用m中的元素初始化的哈希表。
Hashtable
ht=新的Hashtable （映射m）；
JAVA
// Java program to demonstrate // adding elements to Hashtable import java.io.*; import java.util.*; class AddElementsToHashtable { public static void main(String args[]) { // No need to mention the // Generic type twice Map<Integer, String> hm = new HashMap<>(); // Inserting the Elements // using put() method hm.put( 1 , "one" ); hm.put( 2 , "two" ); hm.put( 3 , "three" ); // Initialization of a Hashtable // using Generics Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>(hm); // Print mappings to the console System.out.println( "Mappings of ht2 : " + ht2); } } |
输出
Mappings of ht2 : {3=three, 2=two, 1=one}
例子：
JAVA
// Java program to illustrate // Java.util.Hashtable import java.util.*; public class GFG { public static void main(String[] args) { // Create an empty Hashtable Hashtable<String, Integer> ht = new Hashtable<>(); // Add elements to the hashtable ht.put( "vishal" , 10 ); ht.put( "sachin" , 30 ); ht.put( "vaibhav" , 20 ); // Print size and content System.out.println( "Size of map is:- " + ht.size()); System.out.println(ht); // Check if a key is present and if // present, print value if (ht.containsKey( "vishal" )) { Integer a = ht.get( "vishal" ); System.out.println( "value for key" + " "vishal" is:- " + a); } } } |
输出
Size of map is:- 3
{vaibhav=20, vishal=10, sachin=30}
value for key "vishal" is:- 10
在哈希表上执行各种操作
1.添加元素： 为了向哈希表添加元素，我们可以使用 put（） 方法但是，哈希表中不会保留插入顺序。在内部，对于每个元素，都会生成一个单独的散列，并基于该散列对元素进行索引，以提高效率。
JAVA
// Java program to demonstrate // adding elements to Hashtable import java.io.*; import java.util.*; class AddElementsToHashtable { public static void main(String args[]) { // No need to mention the // Generic type twice Hashtable<Integer, String> ht1 = new Hashtable<>(); // Initialization of a Hashtable // using Generics Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>(); // Inserting the Elements // using put() method ht1.put( 1 , "Geeks" ); ht1.put( 2 , "For" ); ht1.put( 3 , "Geeks" ); ht2.put( 1 , "Geeks" ); ht2.put( 2 , "For" ); ht2.put( 3 , "Geeks" ); // Print mappings to the console System.out.println( "Mappings of ht1 : " + ht1); System.out.println( "Mappings of ht2 : " + ht2); } } |
输出
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks}
Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}
2.改变要素： 在添加元素之后，如果我们希望更改元素，可以通过再次添加带有 put（） 方法由于哈希表中的元素是使用键进行索引的，因此只需插入我们希望更改的键的更新值，就可以更改键的值。
JAVA
// Java program to demonstrate // updating Hashtable import java.io.*; import java.util.*; class UpdatesOnHashtable { public static void main(String args[]) { // Initialization of a Hashtable Hashtable<Integer, String> ht = new Hashtable<Integer, String>(); // Inserting the Elements // using put method ht.put( 1 , "Geeks" ); ht.put( 2 , "Geeks" ); ht.put( 3 , "Geeks" ); // print initial map to the console System.out.println( "Initial Map " + ht); // Update the value at key 2 ht.put( 2 , "For" ); // print the updated map System.out.println( "Updated Map " + ht); } } |
输出
Initial Map {3=Geeks, 2=Geeks, 1=Geeks}
Updated Map {3=Geeks, 2=For, 1=Geeks}
3.移除元件： 为了从地图中删除元素，我们可以使用 删除（） 方法此方法获取密钥值，并从该映射中删除密钥的映射（如果该映射存在于映射中）。
JAVA
// Java program to demonstrate // the removing mappings from Hashtable import java.io.*; import java.util.*; class RemovingMappingsFromHashtable { public static void main(String args[]) { // Initialization of a Hashtable Map<Integer, String> ht = new Hashtable<Integer, String>(); // Inserting the Elements // using put method ht.put( 1 , "Geeks" ); ht.put( 2 , "For" ); ht.put( 3 , "Geeks" ); ht.put( 4 , "For" ); // Initial HashMap System.out.println( "Initial map : " + ht); // Remove the map entry with key 4 ht.remove( 4 ); // Final Hashtable System.out.println( "Updated map : " + ht); } } |
输出
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks}
Updated map : {3=Geeks, 2=For, 1=Geeks}
4.哈希表的遍历： 为了迭代表，我们可以使用 先进的for-loop .下面是迭代哈希表的示例。
JAVA
// Java program to illustrate // traversal of Hashtable import java.util.Hashtable; import java.util.Map; public class IteratingHashtable { public static void main(String[] args) { // Create an instance of Hashtable Hashtable<String, Integer> ht = new Hashtable<>(); // Adding elements using put method ht.put( "vishal" , 10 ); ht.put( "sachin" , 30 ); ht.put( "vaibhav" , 20 ); // Iterating using enhanced for loop for (Map.Entry<String, Integer> e : ht.entrySet()) System.out.println(e.getKey() + " " + e.getValue()); } } |
输出
vaibhav 20 vishal 10 sachin 30
哈希表的内部工作
哈希表数据结构是一个存储桶数组，其中存储键/值对。它利用 hashCode（）方法 来确定键/值对应该映射哪个bucket。 哈希函数有助于确定给定密钥在存储桶列表中的位置。通常，hashcode是一个非负整数，对于相等的对象，它是相等的，对于不相等的对象，它可能是相等的，也可能不是相等的。为了确定两个对象是否相等，hashtable使用equals（）方法。
两个不相等的对象可能具有相同的哈希代码。这叫做 碰撞 .为了解决冲突，哈希表使用列表数组。映射到单个bucket（数组索引）的对存储在列表中，列表引用存储在数组索引中。
哈希表的方法
- K –地图中键的类型。
- 五、 –映射到映射中的值的类型。
|
方法 |
描述 |
|---|---|
| 清除（） | 清除此哈希表，使其不包含任何键。 |
| 克隆（） | 创建此哈希表的浅表副本。 |
| 尝试计算指定键及其当前映射值的映射（如果没有当前映射，则为null）。 | |
| 如果指定的键尚未与值关联（或映射为null），则尝试使用给定的映射函数计算其值，并将其输入该映射，除非为null。 | |
| computeIfPresent（K键，双功能重新映射功能） | 如果指定键的值存在且非空，则会尝试在给定键及其当前映射值的情况下计算新映射。 |
| 包含（对象值） | 测试某些键是否映射到此哈希表中的指定值。 |
| containsKey（对象键） | 测试指定的对象是否是此哈希表中的键。 |
| containsValue（对象值） | 如果此哈希表将一个或多个键映射到此值，则返回true。 |
| 元素（） | 返回此哈希表中值的枚举。 |
| 入口集（） | 返回此映射中包含的映射的集合视图。 |
| 等于（对象o） | 根据映射界面中的定义，将指定对象与此映射进行相等性比较。 |
| 获取（对象键） | 返回指定键映射到的值，如果此映射不包含该键的映射，则返回null。 |
| hashCode（） | 根据映射接口中的定义返回此映射的哈希代码值。 |
| isEmpty（） | 测试此哈希表是否没有键映射到值。 |
| 钥匙（） | 返回此哈希表中键的枚举。 |
| 键集（） | 返回此映射中包含的键的集合视图。 |
| 合并（K键、V值、双函数重新映射函数） | 如果指定的键尚未与值关联或与null关联，则将其与给定的非null值关联。 |
| 输入（K键，V值） | 将指定的键映射到此哈希表中的指定值。 |
| putAll（地图t） | 将指定映射中的所有映射复制到此哈希表。 |
| rehash（） | 增加此哈希表的容量并对其进行内部重组，以便更有效地容纳和访问其条目。 |
| 去除（对象键） | 从此哈希表中删除键（及其对应的值）。 |
| 大小（） | 返回此哈希表中的键数。 |
| toString（） | 以一组条目的形式返回此哈希表对象的字符串表示形式，用大括号括起来，并用ASCII字符“，”（逗号和空格）分隔。 |
| 价值观（） | 返回此映射中包含的值的集合视图。 |
在java接口中声明的方法。util。地图
|
方法 |
描述 |
|---|---|
| forEach（双消费者行动） | 对该映射中的每个条目执行给定操作，直到所有条目都已处理或该操作引发异常为止。 |
| getOrDefault（对象键，V默认值） | 返回指定键映射到的值，如果此映射不包含该键的映射，则返回defaultValue。 |
| putIfAbsent（K键，V值） | 如果指定的键尚未与值关联（或映射为null），则将其与给定值关联并返回null，否则返回当前值。 |
|
去除（对象键， 对象值） |
仅当指定项当前映射到指定值时，才删除该项。 |
| 更换（K键，V值） | 仅当指定项当前映射到某个值时，才替换该项。 |
| 替换（K键，V旧值，V新值） | 仅当当前映射到指定值时，才替换指定键的项。 |
| replaceAll（双功能功能） | 将每个条目的值替换为对该条目调用给定函数的结果，直到处理完所有条目或函数引发异常为止。 |
必须阅读：
参考： https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
![关于”PostgreSQL错误：关系[表]不存在“问题的原因和解决方案-yiteyi-C++库](https://www.yiteyi.com/wp-content/themes/zibll/img/thumbnail.svg)
