In the world of Java, when you need to store key-value pairs, HashMap is often your first thought. But what if you need thread-safety—what if multiple threads need to access and modify your map concurrently without corrupting its data? Enter Hashtable.
While Hashtable might seem like an older, perhaps less frequently used, sibling to HashMap, it offers a distinct advantage: built-in synchronization. Let’s explore Hashtable in detail, understanding its characteristics, how to use it, and when it’s the right choice.
What is Hashtable?
java.util.Hashtable is a concrete implementation of the Map interface in Java. It stores data in key-value pairs and uses a hashing mechanism to efficiently store and retrieve objects. Key characteristics include:
- Synchronization: All public methods of Hashtable are synchronized. This means that only one thread can access a Hashtable instance at a time, ensuring data consistency in a multi-threaded environment.
- Nulls Not Allowed: Unlike HashMap, Hashtable does not allow null keys or null values. Attempting to insert a null key or value will result in a NullPointerException.
- Legacy Class: Hashtable is part of Java’s legacy collections framework, dating back to Java 1.0. While functional, newer (and often more performant) synchronized map implementations like ConcurrentHashMap are generally preferred for new development.
- Initial Capacity and Load Factor: Hashtable uses an initial capacity (default 11) and a load factor (default 0.75). When the number of entries exceeds (capacity * load factor), the Hashtable automatically rehashes and increases its capacity.
Hashtable vs. HashMap: Key Differences
A quick comparison highlights the main distinctions:
| Feature | Hashtable | HashMap |
|---|---|---|
| Synchronization | Synchronized (thread-safe) | Non-synchronized (not thread-safe) |
| Nulls | Does not allow null keys or values | Allows one null key and multiple null values |
| Performance | Generally slower due to synchronization overhead | Generally faster in single-threaded environments |
| Legacy | Legacy class (available since Java 1.0) | Modern class (available since Java 1.2) |
| Fail-fast Iterators | No | Yes |
For more detailed information on fail-fast iterators, it is related to what happens if you modify the collection while iterating over it. Hashmap throws ConcurrentModificationException in such cases.
How to Use Hashtable
Let’s look at some common operations with examples.
1. Creating a Hashtable
You can create a Hashtable with different constructors:
import java.util.Hashtable;
public class HashtableCreation {
public static void main(String[] args) {
// Default constructor: initial capacity 11, load factor 0.75
Hashtable defaultTable = new Hashtable<>();
System.out.println("Default Hashtable: " + defaultTable);
// Constructor with initial capacity
Hashtable initialCapacityTable = new Hashtable<>(20);
System.out.println("Hashtable with initial capacity 20: " + initialCapacityTable);
// Constructor with initial capacity and load factor
Hashtable customTable = new Hashtable<>(20, 0.8f);
System.out.println("Hashtable with custom capacity and load factor: " + customTable);
// Constructor from another Map
Hashtable anotherMap = new Hashtable<>();
anotherMap.put("One", 1);
anotherMap.put("Two", 2);
Hashtable copiedTable = new Hashtable<>(anotherMap);
System.out.println("Hashtable copied from another map: " + copiedTable);
}
}
2. Adding Elements (put())
Use the put(key, value) method to add entries. Remember, no nulls allowed!
import java.util.Hashtable;
public class HashtableAddElements {
public static void main(String[] args) {
Hashtable employees = new Hashtable<>();
employees.put("E101", "Alice");
employees.put("E102", "Bob");
employees.put("E103", "Charlie");
System.out.println("Employees Hashtable: " + employees);
// Trying to add a duplicate key will overwrite the old value
employees.put("E101", "Alicia");
System.out.println("Employees after updating E101: " + employees);
// Attempting to add null key (throws NullPointerException)
try {
employees.put(null, "David");
} catch (NullPointerException e) {
System.out.println("Caught NullPointerException for null key: " + e.getMessage());
}
// Attempting to add null value (throws NullPointerException)
try {
employees.put("E104", null);
} catch (NullPointerException e) {
System.out.println("Caught NullPointerException for null value: " + e.getMessage());
}
}
}
3. Retrieving Elements (get())
Use get(key) to retrieve the value associated with a key.
import java.util.Hashtable;
public class HashtableGetElements {
public static void main(String[] args) {
Hashtable fruits = new Hashtable<>();
fruits.put("Apple", "Red");
fruits.put("Banana", "Yellow");
fruits.put("Grape", "Purple");
System.out.println("Color of Apple: " + fruits.get("Apple"));
System.out.println("Color of Banana: " + fruits.get("Banana"));
System.out.println("Color of Orange (not present): " + fruits.get("Orange")); // Returns null
}
}
4. Removing Elements (remove())
The remove(key) method deletes an entry and returns the value previously mapped to the key.
import java.util.Hashtable;
public class HashtableRemoveElements {
public static void main(String[] args) {
Hashtable studentNames = new Hashtable<>();
studentNames.put(101, "John");
studentNames.put(102, "Jane");
studentNames.put(103, "Doe");
System.out.println("Initial Hashtable: " + studentNames);
String removedName = studentNames.remove(102);
System.out.println("Removed student with ID 102: " + removedName);
System.out.println("Hashtable after removal: " + studentNames);
String nonExistent = studentNames.remove(104);
System.out.println("Attempted to remove non-existent ID 104: " + nonExistent); // Returns null
}
}
5. Checking for Existence (containsKey(), containsValue(), isEmpty())
import java.util.Hashtable;
public class HashtableCheckExistence {
public static void main(String[] args) {
Hashtable prices = new Hashtable<>();
prices.put("Laptop", 1200.00);
prices.put("Mouse", 25.50);
System.out.println("Does prices contain 'Laptop' key? " + prices.containsKey("Laptop"));
System.out.println("Does prices contain 'Keyboard' key? " + prices.containsKey("Keyboard"));
System.out.println("Does prices contain value 25.50? " + prices.containsValue(25.50));
System.out.println("Does prices contain value 100.00? " + prices.containsValue(100.00));
System.out.println("Is prices Hashtable empty? " + prices.isEmpty());
prices.clear(); // Remove all mappings
System.out.println("Is prices Hashtable empty after clear? " + prices.isEmpty());
}
}
6. Iterating Over Hashtable
You can iterate using keySet(), entrySet(), or values().
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
import java.util.Enumeration; // Specific to legacy collections
public class HashtableIteration {
public static void main(String[] args) {
Hashtable capitals = new Hashtable<>();
capitals.put("USA", "Washington D.C.");
capitals.put("France", "Paris");
capitals.put("Germany", "Berlin");
System.out.println("--- Iterating using entrySet() (Recommended) ---");
for (Map.Entry entry : capitals.entrySet()) {
System.out.println("Country: " + entry.getKey() + ", Capital: " + entry.getValue());
}
System.out.println("--- Iterating using keySet() ---");
for (String country : capitals.keySet()) {
System.out.println("Country: " + country + ", Capital: " + capitals.get(country));
}
System.out.println("--- Iterating using values() ---");
for (String capital : capitals.values()) {
System.out.println("Capital: " + capital);
}
// Hashtable also supports Enumeration for keys and values (legacy way)
System.out.println("--- Iterating using Enumeration (Legacy) ---");
Enumeration keys = capitals.keys();
while (keys.hasMoreElements()) {
String country = keys.nextElement();
System.out.println("Country (via Enumeration): " + country + ", Capital: " + capitals.get(country));
}
}
}
When to Use Hashtable?
While Hashtable provides thread-safety, its approach (synchronizing every method) can lead to performance bottlenecks, especially under high contention (many threads trying to access the map simultaneously). Each operation essentially locks the entire map, preventing other threads from acting on it.
For modern Java applications requiring thread-safe maps, ConcurrentHashMap is almost always the better choice. ConcurrentHashMap achieves thread-safety more efficiently by using a finer-grained locking mechanism (or lock-free algorithms in newer versions), allowing multiple read operations and some concurrent write operations.
You might consider using Hashtable in these (rare) scenarios:
- Legacy Code: If you’re working with very old Java code that already uses Hashtable and changing it would be high risk, you might stick with it.
- Learning/Understanding: To understand how basic synchronization works on collections.
- Specific Performance Profiles: In extremely rare cases, for an application with very infrequent writes and many reads where the overhead of ConcurrentHashMap’s more complex internal structure might briefly outweigh Hashtable’s simpler but coarser synchronization. However, this is highly specific and usually not the case.
Conclusion
Hashtable is a foundational part of Java’s collection framework, offering a thread-safe way to store key-value pairs. Its primary advantage is built-in synchronization, making it suitable for multi-threaded environments where data consistency is paramount. However, due to its coarse-grained locking, it can become a performance bottleneck.
For new development, ConcurrentHashMap is the recommended choice for thread-safe map operations, providing superior concurrency and performance. Understanding Hashtable is valuable for comprehending Java’s collection history and basic synchronization principles, but for most modern applications, it’s best to look towards its more sophisticated alternatives.