How does a Hash map handle collisions in JAVA.


In Java, a HashMap is a widely used data structure that implements the Map interface and is part of the Java Collections Framework. It provides a way to store key-value pairs, allowing for efficient retrieval of values based on their associated keys. One of the challenges faced by hash maps is handling collisions, which occur when two or more keys hash to the same index in the underlying array. In this situation, a collision resolution mechanism is required to store and retrieve values accurately. Java’s HashMap uses a combination of techniques, including chaining and open addressing, to address collisions.


Chaining is a common technique used by hash maps to handle collisions. In a chaining approach, each bucket in the hash map is associated with a linked list or another data structure that can store multiple elements. When a collision occurs, the elements with the same hash value are stored in the same bucket as part of the linked list.

How Chaining Works:

  1. Hashing:
    • When a key is inserted into the hash map, its hash code is calculated using the hashCode() method.
    • The hash code is then mapped to an index within the array using a hash function.
  2. Insertion:
    • If the calculated index is empty (no collision), the key-value pair is stored at that index.
    • If a collision occurs (multiple keys hash to the same index), a linked list or another data structure is used to store the key-value pairs at that index.
// Simplified example of inserting a key-value pair
int index = hash(key);
if (table[index] == null) {
    // No collision, store the key-value pair
    table[index] = new Entry<>(key, value);
} else {
    // Collision, use chaining to store in linked list
    table[index].addToChain(new Entry<>(key, value));


  • When retrieving a value for a given key, the hash map calculates the index using the same hash function.
  • If the index is not empty, it searches the linked list at that index for the matching key.
// Simplified example of retrieving a value for a key
int index = hash(key);
Entry<K, V> entry = table[index];
while (entry != null) {
    if (entry.keyEquals(key)) {
        return entry.getValue();
    entry =; // Move to the next node in the linked list

Load Factor and Rehashing:

A critical factor in the efficiency of a hash map is the load factor, which is the ratio of the number of stored elements to the total number of buckets. When the load factor exceeds a certain threshold, the hash map undergoes a process called rehashing.

  1. Load Factor Threshold:
    • The load factor is typically set to a default value (e.g., 0.75) or can be specified by the developer.
    • When the load factor exceeds the threshold, it indicates that the hash map is becoming crowded, and the likelihood of collisions is increasing.
  2. Rehashing:
    • Rehashing involves creating a new, larger array (usually twice the size of the current array) and recalculating the hash codes for all stored keys.
    • The key-value pairs are then redistributed into the new array based on the new hash codes and indices.
// Simplified example of rehashing
int newCapacity = oldCapacity * 2;
Entry<K, V>[] newTable = new Entry[newCapacity];
for (Entry<K, V> entry : oldTable) {
    while (entry != null) {
        int newIndex = newHash(entry.getKey(), newCapacity);
        Entry<K, V> next =; = newTable[newIndex];
        newTable[newIndex] = entry;
        entry = next;
  1. Benefits of Rehashing:
    • Rehashing reduces the likelihood of collisions by increasing the number of buckets, spreading the key-value pairs more evenly across the hash map.
    • It allows the hash map to maintain its efficiency in terms of constant-time average complexity for basic operations (insertion, retrieval, deletion).

Open Addressing:

In addition to chaining, Java’s HashMap also employs a technique known as open addressing to handle collisions. Open addressing involves searching for the next available slot in the array when a collision occurs.

Types of Open Addressing:

  1. Linear Probing:
    • When a collision occurs, the algorithm searches for the next available slot linearly, one position at a time.
    • This can lead to clustering, where consecutive slots are occupied, potentially reducing performance.
  2. Quadratic Probing:
    • Similar to linear probing, but the probing sequence follows a quadratic function (e.g., moving to the next slot, then the slot after that, then the slot two positions away, and so on).
    • Reduces clustering compared to linear probing.
  3. Double Hashing:
    • Uses a secondary hash function to calculate the step size for probing.
    • Offers good dispersion of keys and reduces clustering.

Handling Deletions in Open Addressing:

Handling deletions in open addressing involves marking deleted slots without actually removing the key. When searching for a key, the algorithm continues probing until it finds the key or an empty slot.


In summary, Java’s HashMap handles collisions through a combination of chaining and open addressing. Chaining involves storing multiple elements in the same bucket using linked lists or other data structures. Open addressing addresses collisions by searching for the next available slot in the array. The load factor and rehashing mechanisms ensure that the hash map remains efficient by redistributing key-value pairs when the load factor exceeds a specified threshold. Understanding these collision resolution strategies is crucial for developers working with hash maps to ensure optimal performance in various scenarios.

And get notified everytime we publish a new blog post.

Add a Comment

Your email address will not be published. Required fields are marked *