Rehashing in Java

In the data structure, hashing is the most important concept that is used to convert a given key into another value. The new value can be generated by using the hash function.

In this section, we will understand the concept of rehashing in Java along with the load factor and hashing concept.

Rehashing

Rehashing is a technique that dynamically expands the size of the Map, Array, and Hashtable to maintain the get and put operation complexity of O(1).

It can be also defined as rehashing is the process of re-calculating the hash code of already stored entries and moving them to a bigger size hash map when the number of elements in the map reaches the maximum threshold value.

In simple words, rehashing is the reverse of hashing process. It retains the performance. In rehashing, the load factor plays a vital role.

Load Factor

The load factor is a measure that decides when to increase the HashMap or Hashtable capacity to maintain the get() and put() operation of complexity O(1). The default value of the load factor of HashMap is 0.75 (75% of the map size). In short, we can say that the load factor decides "when to increase the number of buckets to store the key-value pair."

LARGER load factor: Lower space consumption but higher lookups SMALLER Load factor: Larger space consumption compared to the required number of elements.

How Load Factor is Calculated?

Load factor can be calculated by using the following formula:

For example:

The initial capacity of HashMap is = 16
The default load factor of HashMap = 0.75
According to the formula: 16*0.75 = 12

It represents that the 12^th key-value pair of HashMap will keep its size to 16. As soon as the 13^thelement (key-value pair) will come into the HashMap, it will increase its size from default 2⁴ = 16 buckets to 2⁵ = 32 buckets.

Load Factor Example

Let's understand the load factor through an example.

We know that the default bucket size of the HashMap is 16. We insert the first element, now check whether we need to increase the HashMap capacity or not. It can be determined by the formula:

Size of the HashMap (m) / Number of Buckets (n)

In this case, the size of the HashMap is 1, and the bucket size is 16. So, 1/16 = 0.0625. Now compare the obtained value with the default load factor (0.75).

0.0625 < 0.75

The value is smaller than the default value of the load factor. So, no need to increase the HashMap size. Therefore, we do not need to increase the size of the HashMap up to the 12^th element because

12/16 = 0.75

The obtained value is equal to the default load factor, i.e., 0.75.

As soon as, we insert the 13^th element in the HashMap, the size of HashMap is increased because:

13/16 = 0.8125

Here, the obtained value is greater than the default load factor value.

0.8125 > 0.75

In order to insert the 13^th element into the HashMap, we need to increase the HashMap size.

If you want to keep get() and put() operation complexity O(1), it is advisable to have a load factor around 0.75.

Why rehashing is required?

Rehashing is required when the load factor increases. The load factor increases when we insert key-value pair in the map and it also increases the time complexity. Generally, the time complexity of HashMap is O(1). In order to reduce the time complexity and load factor of the HashMap, we implement the rehashing technique.

We should use rehashing for the following conditions:

When the table is half full.
When the load reaches at a certain level (load > 1/2).
When an insertion fails.
Heuristically choose a load factor threshold, rehash when threshold breached.

Implementing Rehashing

The following steps must follow to implement the rehashing process:

Check the load factor for each new insertion of an element to the Map.
If the load factor is greater than its default value (0.75), then implement rehashing.
Create a new bucketArray of double size (i.e. double the size of the previous array).
Iterate over each element of the previous array (old bucketArray) and call the insert() method for each element. The insert() method inserts all the elements in the newly created bucketArray that is of larger size.

Since the cost of rehashing of N elements will be:

Rehashing Java Program

Let's implement the rehashing technique in a Java program.

RehashingExample.java

import java.util.ArrayList;
class Map<K, V> 
{
class MapNode<K, V> 
{
K key;
V value;
MapNode<K, V> next;
//creating a construtor of the MapNode class
public MapNode(K key, V value)
{
this.key = key;
this.value = value;
next = null;
}
}
//creating a bucket array that stores key-value pairs
ArrayList<MapNode<K, V> > buckets;
//variable denotes the number of pairs stored in bucket array - n
int size;
//variable that denotes the size of the bucketArray - b
int numBuckets;
//defining the default loadFactor
final double DEFAULT_LOAD_FACTOR = 0.75;
//creating a construtor of the Map class
public Map()
{
//defining the size of the bucket    
numBuckets = 5;
buckets = new ArrayList<>(numBuckets);
//loop executes upto number of bucket size and sets nodes initially to null
for (int i = 0; i < numBuckets; i++) 
{
//initially bucket is null
buckets.add(null);
}
//prints all the values that are initially set
System.out.println("HashMap created");
System.out.println("Number of pairs in the Map: " + size);
System.out.println("Size of Map: " + numBuckets);
System.out.println("Default Load Factor : " + DEFAULT_LOAD_FACTOR + "\n");
}
private int getBucketInd(K key)
{
//getting the hash code of the corresponding key by invoking the Object class hashCode() method
int hashCode = key.hashCode();
//calculating the array index and returning the same
return (hashCode % numBuckets);
}
//creating a function that inserts elements to the list
public void insert(K key, V value)
{
//Getting the index at which it needs to be inserted
int bucketInd = getBucketInd(key);
// The first node at that index
MapNode<K, V> head = buckets.get(bucketInd);
// First, loop through all the nodes present at that index
// to check if the key already exists
//the loop iterate over all the nodes presented at that index and checks if the key already exists or not
while (head != null) 
{
//if the key is already presented, the value is updated
if (head.key.equals(key)) 
{
head.value = value;
return;
}
head = head.next;
}
//creating a new node with key-value pair
MapNode<K, V> newElementNode = new MapNode<K, V>(key, value);
// The head node at the index
head = buckets.get(bucketInd);
// the new node is inserted
// by making it the head
		// and it's next is the previous head
newElementNode.next = head;
buckets.set(bucketInd, newElementNode);
System.out.println("Pair(" + key + ", " + value + ") inserted successfully.\n");
// Incrementing size
// as new K-V pair is added to the map
size++;
//calculating the load factor
double loadFactor = (1.0 * size) / numBuckets;
System.out.println("Current Load factor = " + loadFactor);
//if the calculated load factor is greater than the default load factor i.e.0.75, the rehashing is done
if (loadFactor > DEFAULT_LOAD_FACTOR) 
{
System.out.println(loadFactor + " is greater than " + DEFAULT_LOAD_FACTOR);
System.out.println("Therefore Rehashing will be done.\n");
//calling the rehash() function
rehash();
System.out.println("New Size of Map: " + numBuckets + "\n");
}
System.out.println("Number of pairs in the Map: " + size);
System.out.println("Size of Map: " + numBuckets + "\n");
}
//function that performs rehashing
private void rehash()
{
System.out.println("\n***Rehashing Started***\n");
//the present bucket list is made temporarly 
ArrayList<MapNode<K, V> > temp = buckets;
//creating a new bucket list of doubled size of the old bucket size i.e. (2 * numBuckets)
buckets = new ArrayList<MapNode<K, V> >(2 * numBuckets);
for (int i = 0; i < 2 * numBuckets; i++) 
{
//initially all elements set to null
buckets.add(null);
}
// Now size is made zero
// and we loop through all the nodes in the original bucket list(temp)
// and insert it into the new list
size = 0;
numBuckets = numBuckets * 2;
for (int i = 0; i < temp.size(); i++) 
{
// head of the chain at that index
MapNode<K, V> head = temp.get(i);
while (head != null) 
{
K key = head.key;
V val = head.value;
// calling the insert function for each node in temp
// as the new list is now the bucketArray
insert(key, val);
head = head.next;
}
}
System.out.println("\n***Rehashing Done***\n");
}
//method to print the map key-value pairs
public void printMap()
{
//creating a temporary bucket list 
ArrayList<MapNode<K, V> > temp = buckets;
System.out.println("Current HashMap:");
//loop iterate over the Map 
for (int i = 0; i < temp.size(); i++) 
{
//getting the head index of the temporary bucket list
MapNode<K, V> head = temp.get(i);
while (head != null) 
{
System.out.println("key = " + head.key + ", val = " + head.value);
head = head.next;
}
}
System.out.println();
}
}
//main class
public class RehashingExample 
{
public static void main(String args[])
{
//creating the instance of the Map class
Map<Integer, String> map = new Map<Integer, String>();
//adding elements to the Map
map.insert(1, "Hyundai");
map.printMap();
map.insert(2, "KIA");
map.printMap();
map.insert(3, "Toyota");
map.printMap();
map.insert(4, "Mahindra");
map.printMap();
map.insert(5, "Jeep");
map.printMap();
map.insert(6, "Ford");
map.printMap();
map.insert(7, "BMW");
map.printMap();
map.insert(8, "Audi"); 
map.printMap();
map.insert(9, "Mercedes-Benz"); 
map.printMap();
map.insert(10, "Ferrari"); 
map.printMap();
}
} 

Output:

HashMap created
Number of pairs in the Map: 0
Size of Map: 5
Default Load Factor : 0.75

Pair(1, Hyundai) inserted successfully.

Current Load factor = 0.2
Number of pairs in the Map: 1
Size of Map: 5

Current HashMap:
key = 1, val = Hyundai

Pair(2, KIA) inserted successfully.

Current Load factor = 0.4
Number of pairs in the Map: 2
Size of Map: 5

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA

Pair(3, Toyota) inserted successfully.

Current Load factor = 0.6
Number of pairs in the Map: 3
Size of Map: 5

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota

Pair(4, Mahindra) inserted successfully.

Current Load factor = 0.8
0.8 is greater than 0.75
Therefore Rehashing will be done.


***Rehashing Started***

Pair(1, Hyundai) inserted successfully.

Current Load factor = 0.1
Number of pairs in the Map: 1
Size of Map: 10

Pair(2, KIA) inserted successfully.

Current Load factor = 0.2
Number of pairs in the Map: 2
Size of Map: 10

Pair(3, Toyota) inserted successfully.

Current Load factor = 0.3
Number of pairs in the Map: 3
Size of Map: 10

Pair(4, Mahindra) inserted successfully.

Current Load factor = 0.4
Number of pairs in the Map: 4
Size of Map: 10


***Rehashing Done***

New Size of Map: 10

Number of pairs in the Map: 4
Size of Map: 10

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra

Pair(5, Jeep) inserted successfully.

Current Load factor = 0.5
Number of pairs in the Map: 5
Size of Map: 10

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep

Pair(6, Ford) inserted successfully.

Current Load factor = 0.6
Number of pairs in the Map: 6
Size of Map: 10

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep
key = 6, val = Ford

Pair(7, BMW) inserted successfully.

Current Load factor = 0.7
Number of pairs in the Map: 7
Size of Map: 10

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep
key = 6, val = Ford
key = 7, val = BMW

Pair(8, Audi) inserted successfully.

Current Load factor = 0.8
0.8 is greater than 0.75
Therefore Rehashing will be done.


***Rehashing Started***

Pair(1, Hyundai) inserted successfully.

Current Load factor = 0.05
Number of pairs in the Map: 1
Size of Map: 20

Pair(2, KIA) inserted successfully.

Current Load factor = 0.1
Number of pairs in the Map: 2
Size of Map: 20

Pair(3, Toyota) inserted successfully.

Current Load factor = 0.15
Number of pairs in the Map: 3
Size of Map: 20

Pair(4, Mahindra) inserted successfully.

Current Load factor = 0.2
Number of pairs in the Map: 4
Size of Map: 20

Pair(5, Jeep) inserted successfully.

Current Load factor = 0.25
Number of pairs in the Map: 5
Size of Map: 20

Pair(6, Ford) inserted successfully.

Current Load factor = 0.3
Number of pairs in the Map: 6
Size of Map: 20

Pair(7, BMW) inserted successfully.

Current Load factor = 0.35
Number of pairs in the Map: 7
Size of Map: 20

Pair(8, Audi) inserted successfully.

Current Load factor = 0.4
Number of pairs in the Map: 8
Size of Map: 20


***Rehashing Done***

New Size of Map: 20

Number of pairs in the Map: 8
Size of Map: 20

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep
key = 6, val = Ford
key = 7, val = BMW
key = 8, val = Audi

Pair(9, Mercedes-Benz) inserted successfully.

Current Load factor = 0.45
Number of pairs in the Map: 9
Size of Map: 20

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep
key = 6, val = Ford
key = 7, val = BMW
key = 8, val = Audi
key = 9, val = Mercedes-Benz

Pair(10, Ferrari) inserted successfully.

Current Load factor = 0.5
Number of pairs in the Map: 10
Size of Map: 20

Current HashMap:
key = 1, val = Hyundai
key = 2, val = KIA
key = 3, val = Toyota
key = 4, val = Mahindra
key = 5, val = Jeep
key = 6, val = Ford
key = 7, val = BMW
key = 8, val = Audi
key = 9, val = Mercedes-Benz
key = 10, val = Ferrari

Next TopicRound Robin Scheduling Program in Java

← prev next →