IdentityHashMap in Java

In Java, a HashMap is a popular implementation of the Map interface that allows us to store and retrieve key-value pairs. However, in some situations, we might need to use an IdentityHashMap instead of a regular HashMap. In this article, we will take a closer look at what an IdentityHashMap is and how it works in Java.

What is an IdentityHashMap?

An IdentityHashMap is a special implementation of the Map interface in Java that uses the reference equality operator (==) instead of the equals() method to compare keys. This means that keys are considered equal if and only if they refer to the same object in memory. In other words, two keys are considered equal if they are the same object, even if their contents are identical.

Unlike a regular HashMap, an IdentityHashMap is not required to obey the general contract of the equals() method, which specifies that two objects that are equal should have the same hash code. Instead, the IdentityHashMap uses the System.identityHashCode() method to generate hash codes for the keys.

How Does IdentityHashMap Work?

When we add a key-value pair to an IdentityHashMap, the hash code of the key is computed using the System.identityHashCode() method. This hash code is then used to determine the bucket in which the entry will be stored.

When we retrieve a value from an IdentityHashMap, the hash code of the key is computed again using the System.identityHashCode() method. This hash code is then used to locate the bucket that contains the entry for the key. If multiple keys in the map have the same memory address, they will be stored in separate buckets, even if their contents are identical.

IdentityHashMap Example

Here is an example of using an IdentityHashMap to store key-value pairs:

import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
public static void main(String[] args) {
Map identityHashMap = new IdentityHashMap<>();
String key1 = "key";
String key2 = new String("key");
identityHashMap.put(key1, "value1");
identityHashMap.put(key2, "value2");
System.out.println("IdentityHashMap: " + identityHashMap);

    String value = identityHashMap.get(key2);
    System.out.println("Value of key 'key2': " + value);
}
}

In this example, we create an IdentityHashMap and add two key-value pairs to it. The first key is a String literal, and the second key is a new String object that has the same value as the first key. We then retrieve the value associated with the second key and print it.

The output of this program is as follows:

IdentityHashMap: {key=value1, key=value2}
Value of key 'key2': value2

As we can see, the IdentityHashMap stores both keys in separate buckets, even though they have the same value.

Conclusion

An IdentityHashMap in Java is a specialized implementation of the Map interface that uses the reference equality operator instead of the equals() method to compare keys. This makes it useful in situations where we need to store keys that have the same value but are different objects in memory. By using the System.identityHashCode() method to compute hash codes, the IdentityHashMap ensures that keys are stored and retrieved correctly, even if their contents are identical.