IdentityHashMap Class in Java

The IdentityHashMap class is similar to the HashMap class. It implements the AbstractMap class. However, it uses reference equality rather than object equality while comparing the key (or values).

It is not the general purpose implementation of Map. While this class implements the Map interface, it intentionally violates Map's general contract that mandates the use of the equals() method when comparing objects.

It is designed especially for the rare cases where the reference-equality semantics are needed. It is used when the user needs the objects to be compared using the reference.

We need to import java.util package to use IdentityHashMap class.

Features of IdentityHashMap

It uses reference equality rather than using the equals() method. It uses the == operator.
It is must to synchronize IdentityHashMap externally as it is not synchronized previously.
The Iterators throw ConcurrentModificationException in while attempting to modify during the iteration.
It provides constant time performance for the basic operations like get and put, assuming that the System.identityHashCode(Object) disperse the elements correctly in the bucket. IdentityHashMap doesn't use hashCode() method instead it uses System.identityHashCode() method. This is a significant difference because now you can use mutable objects as key in Map whose hash code is likely to change when the mapping is stored inside IdentityHashMap.

Syntax:

public class IdentityHashMap <K,V>  extends AbstractMap <K,V> implements Map<K,V>, Serializable, Cloneable

where, K is the key of Object type and V is the value of Object type.

Constructors of IdentityHashMap

There are two ways to create instance of IdentityHashMap:

1. IdentityHashMap():

It creates a new and empty identity hash map with the default expected maximum size that is 21.

Syntax:

2. IdentityHashMap(int ExpectedMaxSize):

It creates a new and empty identity hash map with the given specified expected maximum size.

Syntax:

3. IdentityHashMap(Map m):

It creates a new identity hash map with the key-value pairs given in the specified map.

Syntax:

Methods of the IdentityHashMap Class

Along with the methods inherited from its parent classes, IdentityHashMap defines following methods:

Sr. no.	Method	Description
1.	void clear()	It clears the map i.e. remove all the mappings.
2.	Set entrySet()	It returns a set view of the key-value mappings in the map.
3.	Set keySet()	It returns an identity based set view of keys contained in the hash map.
4.	Object put (Object key, Object value)	It associate the given value with the given key in the identity hash map.
5.	void putAll (Map t)	It copies all the mappings from specified map (in the argument) to the current map. These mappings will replace any mappings the map had for any keys currently specified in the map.
6.	Object remove (Object key)	It removes all the mappings for specified key from the map (if present).
7.	int size()	It returns the number of key value mappings in the identity hash map.
8.	Object clone()	It returns a shallow copy of given identity hash map. However, the keys and values are not cloned.
9.	boolean containsKey (Object key)	It checks whether the specified object is a key in given identity hash map.
10.	boolean containsValue (Object value)	It checks whether the specified object reference is a value in given identity hash map.
11.	boolean equals (Object o)	It compares the specified object with the map to check equality.
12.	Object get (Object key)	It returns the value to which given key is mapped in the identity hash map. And returns null if map contains no mapping for the key.
13.	int hashCode()	It returns the hash code value of the map.
14.	boolean isEmpty()	It returns true if the specified identity hash map contains no mappings.
15.	Collection values()	It returns a collection view of the values placed in the map.

Let's use the methods of the IdentityHashMap class.

IdentityHashMapDemo.java

// importing the necessary classes
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.*;
public class IdentityHashMapDemo {
   public static void main(String args[]) {
      // Creating the instance of IdentityHashmap 
      Map<String, String> ihm = new IdentityHashMap<>();
      // Putting the elements in the map
      // as key value pairs
      ihm.put("Priya", "10100");
      ihm.put("Shravan", "23290");
      ihm.put(new String("Shreya"), "23330");
      ihm.put("Anu", "45000");
      ihm.put("Nirnay", "67700");
      // Declaring a set of the entries
      Set set = ihm.entrySet();
      // Declaring an iterator
      Iterator i = set.iterator();
      // Displaying the elements
      while(i.hasNext()) {
         Map.Entry me = (Map.Entry)i.next();
         System.out.print(me.getKey() + ": ");
         System.out.println(me.getValue());
      }
      System.out.println();
      // ihm.size() compares the objects by reference 
      // and prints size of IdentityHashMap
      System.out.println("Size of IdentityHashMap is: " + ihm.size());
   }
}

Output:

Basic Operations on IdentityHashMap

1. Adding the elements

To add elements into the IdentityHashMap, we have use the put() and putAll() methods. The put() method enters the specified key and value mapped together in the map. When the current key is passed, previous value is replaced by new value. The putAll() method copies all the key value mappings from one map to another.

Example:

Let's consider following example where we implement put() and putAll() methods in a Java program.

IdentityHashMapExample1.java

import java.util.*;
public class IdentityHashMapExample1 {
    public static void main(String[] args)
    {
        // Creating an empty IdentityHashMap
        Map<Integer, String> object_ihm
            = new IdentityHashMap<Integer, String>();
        // adding key and value pairs
        // mapping String values to integer keys
        object_ihm.put(1, "Hello");
        object_ihm.put(2, "How");
        object_ihm.put(3, "Are");
        object_ihm.put(4, "You");
        object_ihm.put(5, "?");
        // displaying the IdentityHashMap
        System.out.println("The initial mappings are: "
                           + object_ihm);
        // inserting existing key along with new value
        // the old value is stored in variable old_value
        String old_value
            = (String)object_ihm.put(1, "Heyyy");
        // verifying the old returned value
        System.out.println("\nReturned value is: "
                           + old_value);
        // displaying the new map
        System.out.println("\nIdentityHashMap after changing the value to existing key:\n " + object_ihm);
        // creating a new Identityhash map and copying using putAll()
        Map<Integer, String> new_IdentityhashMap
            = new IdentityHashMap<Integer, String>();
        new_IdentityhashMap.putAll(object_ihm);
        // Displaying the final IdentityHashMap
        System.out.println("\nThe new IdentityHashMap (copied): "
                           + new_IdentityhashMap);
    }
}

Output:

2. Removing the elements

To delete the mappings (key-value pairs) from the map, we use the remove() method.

Let's consider following example where we use remove() method to delete a mapping in Java program.

IdentityHashMapExample2.java

import java.util.*;
public class IdentityHashMapExample2 {
    public static void main(String[] args)
    {
        // Creating an empty IdentityHashMap
        Map<Integer, String> object_ihm
            = new IdentityHashMap<Integer, String>();
        // adding key and value pairs
        // mapping String values to integer keys
        object_ihm.put(1, "Hello");
        object_ihm.put(2, "How");
        object_ihm.put(3, "Are");
        object_ihm.put(4, "You");
        object_ihm.put(5, "?");
        // displaying the IdentityHashMap
        System.out.println("The initial mappings are: "
                           + object_ihm);
        // removing the existing key-value mapping
        String returned_value = (String)object_ihm.remove(3); 
        // Displaying the new IdentityHashMap
        System.out.println("\nThe new IdentityHashMap is: "
                           + object_ihm);
    }
}

Output:

3. Accessing the elements

To access the elements of an IdentityHashMap we use the get()method.

Let's consider following example where we use get() method to access the mappings from the map.

IdentityHashMapExample3.java

import java.util.*;  
public class IdentityHashMapExample3 {    
    public static void main(String[] args)
    {
        // Creating an empty IdentityHashMap
        Map<Integer, String> object_ihm
            = new IdentityHashMap<Integer, String>();  
        // adding key and value pairs
        // mapping String values to integer keys
        object_ihm.put(1, "Hello");
        object_ihm.put(2, "How");
        object_ihm.put(3, "Are");
        object_ihm.put(4, "You");
        object_ihm.put(5, "?");
  
        // displaying the IdentityHashMap
        System.out.println("The initial mappings are: "
                           + object_ihm);
        // accessing the value of 5
        System.out.println("Value of key 5 is:"
                           + object_ihm.get(5));
        // accessing the value of 2
        System.out.println("Value of key 2 is:"
                           + object_ihm.get(2));
        // getting the set view of keys using keySet()
        System.out.println("Set view of keys: "
                           + object_ihm.keySet());
        // getting the set view using entrySet()
        System.out.println("The set is: "
                           + object_ihm.entrySet());
    }
}

Output:

4. Traversing through IdentityHashMap

To traverse over the all the structures of Collection Framework, we use Iterator interface. As the Iterators work with only single type of data, we use Entry to resolve two separate types in a compatible format. Then we will use the next() method to print the elements of IdentityHashMap.

IdentityHashMapExample4.java

import java.util.*;
public class IdentityHashMapExample4 {
    public static void main(String[] args)
    {
        // Creating an empty IdentityHashMap
        Map<Integer, String> object_ihm
            = new IdentityHashMap<Integer, String>();
  
        // adding key and value pairs
        // mapping String values to integer keys
        object_ihm.put(1, "Hello");
        object_ihm.put(2, "How");
        object_ihm.put(3, "Are");
        object_ihm.put(4, "You");
        object_ihm.put(5, "?");
  
        // displaying the IdentityHashMap
        System.out.println("The initial mappings are: "
                           + object_ihm);  
        // creating an Iterator to traverse over IdentityHashMap
        Iterator<IdentityHashMap.Entry<Integer, String> >
        itr = object_ihm.entrySet().iterator();
        // hasNext() method is used to check if there is a next element 
        //The next() method is used to retrieve the next element
        while (itr.hasNext()) {
            IdentityHashMap.Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key : " + entry.getKey()
                               + ", Value : "
                               + entry.getValue());
        }
    }
} 

Output:

Difference Between IdentityHashMap and HashMap

The IdentityHashMap uses equality operator (==) to compare the key and value while the HashMap uses the equals() method to compare key and value inside the Map.
As the IdentityHashMap doesn't use equals() method it is faster than the HashMap.
IdentityHashMap doesn't require keys to be immutable as it is not dependant on equals().

The following example explains the difference between IdentityHashMap and HashMap classes.

IdentityHashMapVSHashMap.java

//importing necessary libraries
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;  
public class IdentityHashMapVSHashMap 
{
    public static void main(String[] args) 
    {
        // creating objects of HashMap and IdentityHashMap
        Map<String, String> hm = new HashMap<>();
        Map<String, String> ihm = new IdentityHashMap<>();  
        // adding the key value mappings in HashMap object
        hm.put("Hello","505");
        hm.put(new String("Hello"),"101"); 
        // adding the key value mappings in HashMap object        
        ihm.put("Hello","202"); 
        ihm.put(new String("Hello"),"506"); 
        // displaying both the maps
        System.out.println("HashMap elements: " + hm);
        System.out.println("HashMap elements: " + ihm);          
        // printing the size of HashMap and IdentityHashMap objects
        // hm.size() will print 1 since it compares the objects logically
        // and both the keys are same
        System.out.println("Size of HashMap is : "+hm.size());          
        // ihm.size() will print 2 since it compares the objects by reference
        System.out.println("Size of IdentityHashMap is : "+ihm.size());         
    }
}

Output:

Synchronized IdentityHashMap

When more than one threads access the identity hash map concurrently, and at least one of the threads structurally modifies the map, it is necessary to synchronize that map externally. (Structural modification of map is to add or delete one or more key value mappings. If we just change the value associated with a key that an instance contains already is not structural modification.)

It can be achieved by synchronizing on any object that encapsulate the map. If such object doesn't exist, map should be wrapped with the help of Collections.synchronizedMap() method. The correct time to do this is at the time of creation, in order to prevent unsynchronized access to map.

Syntax:

where, K is type of keys in the map and V is type of values mapped with it.

Next TopicJava BF

← prev next →