
Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:
Once the early-adopter seats are all used, the price will go up and stay at $33/year.
Last updated: January 8, 2024
Hashtable is the oldest implementation of a hash table data structure in Java. The HashMap is the second implementation, which was introduced in JDK 1.2.
Both classes provide similar functionality, but there are also small differences, which we’ll explore in this tutorial.
Let’s say we have a dictionary, where each word has its definition. Also, we need to get, insert and remove words from the dictionary quickly.
Hence, Hashtable (or HashMap) makes sense. Words will be the keys in the Hashtable, as they are supposed to be unique. Definitions, on the other hand, will be the values.
Let’s continue with the dictionary example. We’ll model Word as a key:
public class Word {
private String name;
public Word(String name) {
this.name = name;
}
// ...
}
Let’s say the values are Strings. Now we can create a Hashtable:
Hashtable<Word, String> table = new Hashtable<>();
First, let’s add an entry:
Word word = new Word("cat");
table.put(word, "an animal");
Also, to get an entry:
String definition = table.get(word);
Finally, let’s remove an entry:
definition = table.remove(word);
There are many more methods in the class, and we’ll describe some of them later.
But first, let’s talk about some requirements for the key object.
To be used as a key in a Hashtable, the object mustn’t violate the hashCode() contract. In short, equal objects must return the same code. To understand why let’s look at how the hash table is organized.
Hashtable uses an array. Each position in the array is a “bucket” which can be either null or contain one or more key-value pairs. The index of each pair is calculated.
But why not to store elements sequentially, adding new elements to the end of the array?
The point is that finding an element by index is much quicker than iterating through the elements with the comparison sequentially. Hence, we need a function that maps keys to indexes.
The simplest example of such mapping is the direct-address table. Here keys are used as indexes:
index(k)=k,
where k is a key
Keys are unique, that is each bucket contains one key-value pair. This technique works well for integer keys when the possible range of them is reasonably small.
But we have two problems here:
hashCode() method solves the first problem.
The logic for data manipulation in the Hashtable solves the second problem.
Let’s discuss this in depth.
Any Java object inherits the hashCode() method which returns an int value. This value is calculated from the internal memory address of the object. By default hashCode() returns distinct integers for distinct objects.
Thus any key object can be converted to an integer using hashCode(). But this integer may be big.
get(), put() and remove() methods contain the code which solves the second problem – reducing the range of possible integers.
The formula calculates an index for the key:
int index = (hash & 0x7FFFFFFF) % tab.length;
Where tab.length is the array size, and hash is a number returned by the key’s hashCode() method.
As we can see index is a reminder of the division hash by the array size. Note that equal hash codes produce the same index.
Furthermore, even different hash codes can produce the same index. We refer to this as a collision. To resolve collisions Hashtable stores a LinkedList of key-value pairs.
Such data structure is called a hash table with chaining.
It is easy to guess that collisions slow down operations with elements. To get an entry it is not enough to know its index, but we need to go through the list and perform a comparison with each item.
Therefore it’s important to reduce the number of collisions. The bigger is an array, the smaller is the chance of a collision. The load factor determines the balance between the array size and the performance. By default, it’s 0.75 which means that the array size doubles when 75% of the buckets become not empty. This operation is executed by rehash() method.
But let’s return to the keys.
When we put an entry into a Hashtable and get it out of it, we expect that the value can be obtained not only with same the instance of the key but also with an equal key:
Word word = new Word("cat");
table.put(word, "an animal");
String extracted = table.get(new Word("cat"));
To set the rules of equality, we override the key’s equals() method:
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Word))
return false;
Word word = (Word) o;
return word.getName().equals(this.name);
}
But if we don’t override hashCode() when overriding equals() then two equal keys may end up in the different buckets because Hashtable calculates the key’s index using its hash code.
Let’s take a close look at the above example. What happens if we don’t override hashCode()?
Equal keys must return equal hash codes, that’s why we override the hashCode() method:
public int hashCode() {
return name.hashCode();
}
Note that it’s also recommended to make not equal keys return different hash codes, otherwise they end up in the same bucket. This will hit the performance, hence, losing some of the advantages of a Hashtable.
Also, note that we don’t care about the keys of String, Integer, Long or another wrapper type. Both equal() and hashCode() methods are already overridden in wrapper classes.
There are a few ways to iterate Hashtables. In this section well talk about them and explain some of the implications.
Fail-fast iteration means that if a Hashtable is modified after its Iterator is created, then the ConcurrentModificationException will be thrown. Let’s demonstrate this.
First, we’ll create a Hashtable and add entries to it:
Hashtable<Word, String> table = new Hashtable<Word, String>();
table.put(new Word("cat"), "an animal");
table.put(new Word("dog"), "another animal");
Second, we’ll create an Iterator:
Iterator<Word> it = table.keySet().iterator();
And third, we’ll modify the table:
table.remove(new Word("dog"));
Now if we try to iterate through the table, we’ll get a ConcurrentModificationException:
while (it.hasNext()) {
Word key = it.next();
}
java.util.ConcurrentModificationException
at java.util.Hashtable$Enumerator.next(Hashtable.java:1378)
ConcurrentModificationException helps to find bugs and thus avoid unpredictable behavior, when, for example, one thread is iterating through the table, and another one is trying to modify it at the same time.
Enumeration in a Hashtable is not fail-fast. Let’s look at an example.
First, let’s create a Hashtable and add entries to it:
Hashtable<Word, String> table = new Hashtable<Word, String>();
table.put(new Word("1"), "one");
table.put(new Word("2"), "two");
Second, let’s create an Enumeration:
Enumeration<Word> enumKey = table.keys();
Third, let’s modify the table:
table.remove(new Word("1"));
Now if we iterate through the table it won’t throw an exception:
while (enumKey.hasMoreElements()) {
Word key = enumKey.nextElement();
}
Also, note that iteration order in a Hashtable is unpredictable and does not match the order in which the entries were added.
This is understandable as it calculates each index using the key’s hash code. Moreover, rehashing takes place from time to time, rearranging the order of the data structure.
Hence, let’s add some entries and check the output:
Hashtable<Word, String> table = new Hashtable<Word, String>();
table.put(new Word("1"), "one");
table.put(new Word("2"), "two");
// ...
table.put(new Word("8"), "eight");
Iterator<Map.Entry<Word, String>> it = table.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Word, String> entry = it.next();
// ...
}
}
five
four
three
two
one
eight
seven
Hashtable and HashMap provide very similar functionality.
Both of them provide:
But there are some differences too:
Java 8 has introduced new methods which help make our code cleaner. In particular, we can get rid of some if blocks. Let’s demonstrate this.
Let’s say we need to get the definition of the word “dog” and assign it to the variable if it is on the table. Otherwise, assign “not found” to the variable.
Before Java 8:
Word key = new Word("dog");
String definition;
if (table.containsKey(key)) {
definition = table.get(key);
} else {
definition = "not found";
}
After Java 8:
definition = table.getOrDefault(key, "not found");
Let’s say we need to put a word “cat“ only if it’s not in the dictionary yet.
Before Java 8:
if (!table.containsKey(new Word("cat"))) {
table.put(new Word("cat"), definition);
}
After Java 8:
table.putIfAbsent(new Word("cat"), definition);
Let’s say we need to remove the word “cat” but only if it’s definition is “an animal”.
Before Java 8:
if (table.get(new Word("cat")).equals("an animal")) {
table.remove(new Word("cat"));
}
After Java 8:
boolean result = table.remove(new Word("cat"), "an animal");
Finally, while old remove() method returns the value, the new method returns boolean.
Let’s say we need to replace a definition of “cat”, but only if its old definition is “a small domesticated carnivorous mammal”.
Before Java 8:
if (table.containsKey(new Word("cat"))
&& table.get(new Word("cat")).equals("a small domesticated carnivorous mammal")) {
table.put(new Word("cat"), definition);
}
After Java 8:
table.replace(new Word("cat"), "a small domesticated carnivorous mammal", definition);
This method is similar to putIfabsent(). But putIfabsent() takes the value directly, and computeIfAbsent() takes a mapping function. It calculates the value only after it checks the key, and this is more efficient, especially if the value is difficult to obtain.
table.computeIfAbsent(new Word("cat"), key -> "an animal");
Hence, the above line is equivalent to:
if (!table.containsKey(cat)) {
String definition = "an animal"; // note that calculations take place inside if block
table.put(new Word("cat"), definition);
}
This method is similar to the replace() method. But, again, replace() takes the value directly, and computeIfPresent() takes a mapping function. It calculates the value inside of the if block, that’s why it’s more efficient.
Let’s say we need to change the definition:
table.computeIfPresent(cat, (key, value) -> key.getName() + " - " + value);
Hence, the above line is equivalent to:
if (table.containsKey(cat)) {
String concatination=cat.getName() + " - " + table.get(cat);
table.put(cat, concatination);
}
Now we’ll solve another task. Let’s say we have an array of String, where the elements are not unique. Also, let’s calculate how many occurrences of a String we can get in the array. Here is the array:
String[] animals = { "cat", "dog", "dog", "cat", "bird", "mouse", "mouse" };
Also, we want to create a Hashtable which contains an animal as a key and the number of its occurrences as a value.
Here is a solution:
Hashtable<String, Integer> table = new Hashtable<String, Integer>();
for (String animal : animals) {
table.compute(animal,
(key, value) -> (value == null ? 1 : value + 1));
}
Finally, let’s make sure, that the table contains two cats, two dogs, one bird and two mouses:
assertThat(table.values(), hasItems(2, 2, 2, 1));
There is another way to solve the above task:
for (String animal : animals) {
table.merge(animal, 1, (oldValue, value) -> (oldValue + value));
}
The second argument, 1, is the value which is mapped to the key if the key is not yet on the table. If the key is already in the table, then we calculate it as oldValue+1.
This is a new way to iterate through the entries. Let’s print all the entries:
table.forEach((k, v) -> System.out.println(k.getName() + " - " + v)
Additionally, we can replace all the values without iteration:
table.replaceAll((k, v) -> k.getName() + " - " + v);
In this article, we’ve described the purpose of the hash table structure and showed how to complicate a direct-address table structure to get it.
Additionally, we’ve covered what collisions are and what a load factor is in a Hashtable. Also, we’ve learned why to override equals() and hashCode() for key objects.
Finally, we’ve talked about Hashtable‘s properties and Java 8 specific API.