Hashtable in Java

The Hashtable class in Java is a legacy data structure that stores data in key-value pairs using a hash table. It is part of the Collections Framework and provides synchronized data access.

• Stores data as key-value pairs with no null keys or values allowed.
• Uses hashing (hashCode and equals) to store and retrieve elements efficiently.
• It is synchronized, making it thread-safe but slower than HashMap.

Syntax

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable

Parameters:

• K : the type of keys maintained by this map
• V : the type of mapped values

Hashtable Elements: {Two =2, Three =3, One =1}

In general, it's recommended to use the Map interface or one of its implementations (such as HashMap or ConcurrentHashMap) instead of the Hashtable class.

Note: While the Hashtable class still exists in Java and can still be used, it's generally recommended to use the Map interface or one of its implementations instead.

Hashtable implements Serializable, Cloneable, Map<K,V> interfaces and extends Dictionary<K,V>. The direct subclasses are Properties, UIDefaults.

Constructors

In order to create a Hashtable, we need to import it from java.util.Hashtable. There are various ways in which we can create a Hashtable.

1. Hashtable()

This creates an empty hashtable with the default load factor of 0.75 and an initial capacity is 11. 

Hashtable<K, V> ht = new Hashtable<K, V>();

Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {6=six, 5=five, 4=four}

2. Hashtable(int initialCapacity)

This creates a hash table that has an initial size specified by initialCapacity and the default load factor is 0.75.

Hashtable<K, V> ht = new Hashtable<K, V>(int initialCapacity);

Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {4=four, 6=six, 5=five}

3. Hashtable(int size, float fillRatio)

This version creates a hash table that has an initial size specified by size and fill ratio specified by fillRatio. fill ratio: Basically, it determines how full a hash table can be before it is resized upward and its Value lies between 0.0 to 1.0.

Hashtable<K, V> ht = new Hashtable<K, V>(int size, float fillRatio);

Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {6=six, 5=five, 4=four}

4. Hashtable(Map<? extends K,? extends V> m)

This creates a hash table that is initialized with the elements in m.

Hashtable<K, V> ht = new Hashtable<K, V>(Map m);

Mappings of ht2 : {3=three, 2=two, 1=one}

Example:

Size of map is: 3
{vaibhav=20, vishal=10, sachin=30}
value for key "vishal" is: 10

Performing Various Operations on Hashtable                  

1. Adding Elements

Elements are added to a Hashtable using the put() method. It does not maintain insertion order and stores elements based on generated hash values for efficient access.                      

Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks}
Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}

2. Changing Elements

To update an element in a Hashtable, use the put() method with the same key; it replaces the existing value for that key.

Initial Map {3=Geeks, 2=Geeks, 1=Geeks}
Updated Map {3=Geeks, 2=For, 1=Geeks}

3. Removing Element

In order to remove an element from the Map, we can use the remove() method. This method takes the key value and removes the mapping for a key from this map if it is present in the map.

Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks}
Updated map : {3=Geeks, 2=For, 1=Geeks}

4. Traversal of a Hashtable

To iterate the table, we can make use of an advanced for loop. Below is the example of iterating a hashtable.

vaibhav 20
vishal 10
sachin 30

Internal Working of Hashtable

Hashtable internally uses an array of buckets to store key-value pairs. It uses the hashCode() method to determine the index (bucket) where the data should be stored.

• The hash function converts a key into an index, ensuring fast access.
• The equals() method is used to compare keys and identify the correct value.
• In case of collision (same hashcode), elements are stored in a linked list (bucket) at that index.

👁 HashTable Collision

Methods of Hashtable

• K : The type of the keys in the map.
• V : The type of values mapped in the map.

Advantages

• Provides fast data retrieval using key-value pairs.
• Thread-safe because all methods are synchronized.
• Stores unique keys to avoid duplicate entries.
• Search, insertion, and deletion operations are efficient.
• Suitable for multi-threaded applications where data safety is required.

Limitations

• Hashtable is synchronized, so it is slower compared to HashMap.
• It does not allow null keys or null values.
• Iteration performance is slower because of thread-safety overhead.
• It is considered a legacy class in Java Collections Framework.
• No proper support for modern collection features like fail-fast iterators.

Methods Declared in interface java.util.Map