Internal Working of HashMap in Java

In this article, we will understand the internal workings of the HashMap in Java, also how the get() and put() method functions, how hashing is done, how key-value pairs are stored, and how the values are retrieved by keys.

Basic Structure of a HashMap

HashMap contains an array of Node objects. Each node represents a key-value mapping. This process is defined below:

class Node {

int hash;

K key;

V value;

Node next;

}

Each node stores,

• hash: the hash code of the key
• key: the key object
• value: the associated value
• next: reference to the next node in case of a collision

Now we will see how this works. First, we will see the hashing process. 

Hashing in HashMap

Hashing is the process of converting an object into an integer by using the hashCode() method. It's necessary to write the hashCode() method properly for better performance of the HashMap. HashMap uses the hashCode() method to determine the bucket location for a key.

Custom Key Class Example:

// Custom Key class to override hashCode() and equals()
class Key {
  String key;

  Key(String key) {
    this.key = key;
  }

  @Override
  public int hashCode() {
    
    // ASCII value of first char
    return (int) key.charAt(0); 
  }

  @Override
  public boolean equals(Object obj) {
    return key.equals((String) obj);
  }
}

Here override hashCode() method returns the first character's ASCII value as hash code. So, whenever the first character of the key is same, the hash code will be the same.

Note: You should not approach these criteria in your program. It is just for demo purposes. As HashMap also allows a null key, so hash code of null will always be 0.

hashCode() Method

The hashCode() method is used to get the hash code of an object. hashCode() method of the object class returns the memory reference of an object in integer form. Definition of hashCode() method is public native hashCode(). It indicates the implementation of hashCode() is native because there is not any direct method in Java to fetch the reference of the object. It is possible to provide your implementation of hashCode(). In HashMap, hashCode() is used to calculate the bucket and therefore calculate the index. 

Syntax:

public int hashCode() {

// Implementation to calculate and return the hash code

}

The hashCode() method in Java does not take any parameters explicitly. Its purpose is to the return an integer hash code value that represents the object's identity or contents.

Example:

import java.util.HashMap;

public class Geeks {

    public static void main(String[] args) {
        
        // Creating Student objects
        Student student1 = new Student(1, "Geek1");
        Student student2 = new Student(2, "Geek2");
        Student student3 = new Student(1, "Geek3"); 
        
        // Creating a HashMap with Student as key and grade as value
        HashMap<Student, String> hm = new HashMap<>();
        
        // Adding elements to the HashMap
        hm.put(student1, "A Grade");
        hm.put(student2, "B Grade");  
        
        // Retrieving values using keys
        System.out.println("Grade of student1: " + hm.get(student1)); 
        System.out.println("Grade of student2: " + hm.get(student2)); 
        
        // Using student3 (same id as student1) to retrieve value
        System.out.println("Grade of student3: " + hm.get(student3)); 
    }
}

// Student class with overridden hashCode and equals based on id only
class Student {
    private int id;
    private String name;
    
    // Constructor
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    // Override hashCode method using only id
    @Override
    public int hashCode() {
        return 31 * id;
    }
    
    // Override equals method using only id
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student student = (Student) obj;
        return id == student.id;
    }
}

Grade of student1: A Grade
Grade of student2: B Grade
Grade of student3: A Grade

Explanation of the above Program:

• The program demonstrates how to correctly implement hashCode and equals methods in a custom Student class to ensure proper behavior in a HashMap.
• By overriding these methods, the program ensures that two Student objects with the same id and name are considered equal and produce the same hash code, allowing consistent retrieval of values associated with these keys from the HashMap.

equals() Method

The equals() method is used to check whether 2 objects are equal or not. This method is provided by the Object class. You can override this in your class to provide your implementation. 
HashMap uses equals() to compare the key to whether they are equal or not. If the equals() method return true, they are equal otherwise not equal. 

Syntax:

public boolean equals(Object obj) {

// Implementation to compare the current object with another object

}

The equals() method takes an object as a parameter and returns a boolean indicating whether the current object is equal to the provided object.

Example:

import java.util.HashMap;

public class Geeks {

    public static void main(String[] args) {
        
        // Create Geek objects
        Geek geek1 = new Geek("Geek1", 101, "Java");
        Geek geek2 = new Geek("Geek2", 102, "Python");
        Geek geek3 = new Geek("Geek1", 103, "C++"); 
        
        // Create HashMap
        HashMap<Geek, String> hm = new HashMap<>();
        
        // Add geeks to HashMap
        hm.put(geek1, "Web Development");
        hm.put(geek2, "Data Science");
        
        // Retrieve values
        System.out.println("Project for Geek1: " + hm.get(geek1));
        System.out.println("Project for Geek2: " + hm.get(geek2));
        System.out.println("Project for Geek3: " + hm.get(geek3)); 
    }
}

class Geek {
    private String name;
    private int id;
    private String expertise;
    
    public Geek(String name, int id, String expertise) {
        this.name = name;
        this.id = id;
        this.expertise = expertise;
    }
    
    @Override
    public int hashCode() {
        
        // Using name field for hashCode 
        return 31 * name.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        
        // Check if same object instance
        if (this == obj) {
            return true;
        }
        
        // Check if null or different class
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        
        // Cast to Geek
        Geek other = (Geek) obj;
        
        // Compare name fields
        return name.equals(other.name);
    }
}

Project for Geek1: Web Development
Project for Geek2: Data Science
Project for Geek3: Web Development

Buckets

A bucket is an element of the HashMap array. It is used to store nodes. Two or more nodes can have the same bucket. In that case, a link list structure is used to connect the nodes. Buckets are different in capacity.

Load Factor and Capacity:

capacity = number of buckets * load factor

A single bucket can have more than one node, it depends on the hashCode() method. The better your hashCode() method is, the better your buckets will be utilized. 

Index Calculation

Generated hash code may be in the range of integer and if we create arrays for such a range, then it will easily cause outOfMemoryException. So we generate an index to minimize the size of the array. The following operation is performed to calculate the index. 

Formula to Calculate Index:

index = hashCode(key) & (n-1).

Here, n is the number of buckets or the size of the array. In our example, we will consider n as the default size which is 16. 

Why the above method is used to calculate the index?

Using a bitwise AND operator is similar to doing bit masking wherein only the lower bits of the hash integer is considered which in turn provides a very efficient method of calculating the modulus based on the length of the hashmap.

Initially Empty hashMap:

Here, the hashmap's size is taken as 16.  

HashMap map = new HashMap();

Internally, the default capacity is 16, so the array looks like below:

Internal Working of put() Method in HashMap

Inserting first Key-Value Pair:

When we insert a key-value pair into a HashMap using the put() method, the following internal steps take place:

map.put(new Key("vishal"), 20);

Steps: 

• Calculate hash code of Key {"vishal"}. It will be generated as 118.
• Calculate index by using index method it will be 6.
• Create a node object as: 

{
int hash = 118

// {"vishal"} is not a string but
// an object of class Key
Key key = {"vishal"}

Integer value = 20
Node next = null
}

Place this object at index 6, if no other object is presented there.

Inserting Second Key-Value Pair:

Now, putting the other pair that is, 

map.put(new Key("sachin"), 30);

Steps:

• Calculate hashCode of Key {"sachin"}. It will be generated as 115.
• Calculate index by using index method it will be 3.
• Create a node object as: 

{
int hash = 115
Key key = {"sachin"}
Integer value = 30
Node next = null
}

Inserting Third Key-Value Pair (Collision Example):

Now, putting another pair that is, 

map.put(new Key("vaibhav"), 40);

Steps: 

• Calculate hash code of Key {"vaibhav"}. It will be generated as 118.
• Calculate index by using index method it will be 6.
• Create a node object as:

{
int hash = 118
Key key = {"vaibhav"}
Integer value = 40
Node next = null
}

Place this object at index 6 if no other object is presented there. In this case, a node object is found at index 6 - this is a case of collision. In that case, check via the hashCode() and equals() method if both the keys are the same. If keys are the same, replace the value with the current value. Otherwise, connect this node object to the previous node object via linked list and both are stored at index 6. 

Now HashMap becomes:

Internal Working of get() Method

Now let's try some get methods to get a value. get(K key) method is used to get a value by its key. If you don't know the key then it is not possible to fetch a value. 

Example 1: Fetch the data for key "sachin":

map.get(new Key("sachin"));

Steps: 

1. Calculate hash code of Key {"sachin"}. It will be generated as 115.
2. Calculate index by using index method it will be 3.
3. Go to index 3 of the array and compare the first element's key with the given key. If both are equals then return the value, otherwise, check for the next element if it exists.
4. In our case, it is found as the first element and the returned value is 30.

Example 2: Fetch the data for key "vaibhav": 

map.get(new Key("vaibhav"));

Steps: 

1. Calculate hash code of Key {"vaibhav"}. It will be generated as 118.
2. Calculate index by using index method it will be 6.
3. Go to index 6 of the array and compare the first element's key with the given key. If both are equals then return the value, otherwise, check for the next element if it exists.
4. In our case, it is not found as the first element and the next node object is not null.
5. If the next node is null then return null.
6. If the next of node is not null traverse to the second element and repeat process 3 until the key is not found or next is not null.
7. Time complexity is almost constant for the put and the get method until rehashing is not done.
8. In case of collision, i.e. index of two or more nodes are the same, nodes are joined by a link list i.e. the second node is referenced by the first node and the third by the second, and so on.
9. If the key given already exist in HashMap, the value is replaced with the new value.
10. hash code of the null key is 0.
11. When getting an object with its key, the linked list is traversed until the key matches or null is found on the next field.