Clase IdentityHashMap en Java

IdentityHashMap implementa la interfaz Map usando Hashtable , usando la igualdad de referencia en lugar de la igualdad de objetos al comparar claves (y valores). Esta clase no es una implementación de mapa de propósito general. Si bien esta clase implementa la interfaz Map, viola intencionalmente el contrato general de Map, que exige el uso del método equals() al comparar objetos. Esta clase se utiliza cuando el usuario requiere que los objetos se comparen por referencia. Pertenece al paquete java.util .

Características de IdentityHashMap

• Sigue la igualdad de referencia, en lugar de usar el método equals(), usa el operador ==.
• No está sincronizado y debe sincronizarse externamente.
• Los iteradores fallan rápido, lanzan ConcurrentModificationException en un intento de modificar durante la iteración.
• Esta clase proporciona un rendimiento de tiempo constante para las operaciones básicas (obtener y poner), asumiendo que la función hash de identidad del sistema (System.identityHashCode(Object)) dispersa los elementos correctamente entre los cubos. IdentityHashMap no usa el método hashCode() sino que usa el método System.identityHashCode(). Esta es una diferencia significativa porque ahora puede usar objetos mutables como clave en Map, cuyo código hash probablemente cambie cuando el mapeo se almacena dentro de IdentityHashMap.

Declaración:

clase pública IdentityHashMap<K,​V> extiende AbstractMap<K,​V> implementa Map<K,​V>, serializable, clonable 
 

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor.

La jerarquía de IdentityHashMap

Implementa interfaces Serializable , Cloneable , Map<K,​ V> y extiende la clase AbstractMap<K, V> .

Ejemplo:

// Java code to demonstrate IdentityHashMap
 
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;
 
public class IdentityHashMapExample
{
    public static void main(String[] args)
    {
        // creating an instance of IdentityHashMap
        Map<String, String> ihm = new IdentityHashMap<>();
 
        // Putting key and value pair
        // in a IdentityHashMap Object
        ihm.put("ihmkey","ihmvalue");
        ihm.put(new String("ihmkey"),"ihmvalue1");
         
        // ihm.size() will print 2 since it
        // compares the objects by reference
        System.out.println("Size of IdentityHashMap--"+ihm.size());
         
    }
}

Size of IdentityHashMap--2

Constructores de IdentityHashMap

Podemos crear una instancia de IdentityHashMap de dos maneras:

IdentityHashMap<K, V> ihm = new IdentityHashMap<K, V>();
            (or)
Map<K, V> hm = new IdentityHashMap<K, V>();

1. IdentityHashMap():  construye un nuevo mapa hash de identidad vacío con un tamaño máximo esperado predeterminado. 

IdentityHashMap<K, V> ihm = new IdentityHashMap<K, V>();

2. IdentityHashMap(int expectedMaxSize):  Construye un nuevo mapa vacío con el tamaño máximo esperado especificado. 

IdentityHashMap<K, V> ihm = new IdentityHashMap(int MaxSize esperado);

3. IdentityHashMap(Map m):  construye un nuevo mapa hash de identidad que contiene las asignaciones clave-valor en el mapa especificado.

IdentityHashMap<K, V> ihm = new IdentityHashMap(Mapa m);

Operaciones básicas en IdentityHashMap

1. Agregar elementos

Para insertar o agregar mapeo en un IdentityHashMap, tenemos los métodos put() y putAll() . put() puede insertar una clave específica y el valor que está mapeando, en un mapa particular. Si se pasa una clave existente, el valor anterior se reemplaza por el nuevo valor. putAll() copia todos los elementos, es decir, las asignaciones, de un mapa a otro. 

// Java code to illustrate
// adding elements to IdentityHashMap
import java.util.*;
 
public class AddingElementsToIdentityHashMap {
   
    public static void main(String[] args)
    {
        // Creating an empty IdentityHashMap
        Map<Integer, String> identity_hash
            = new IdentityHashMap<Integer, String>();
 
        // Mapping string values to int keys
        // using put() method
        identity_hash.put(10, "Geeks");
        identity_hash.put(15, "4");
        identity_hash.put(20, "Geeks");
        identity_hash.put(25, "Welcomes");
        identity_hash.put(30, "You");
 
        // Displaying the IdentityHashMap
        System.out.println("Initial Mappings are: "
                           + identity_hash);
 
        // Inserting existing key along with new value
          // previous value gets returned and stored in
          // returned_value
        String returned_value
            = (String)identity_hash.put(20, "All");
 
        // Verifying the returned value
        System.out.println("Returned value is: "
                           + returned_value);
 
        // Displaying the new map
        System.out.println("New map is: " + identity_hash);
 
        // Creating a new Identityhash map and copying
        Map<Integer, String> new_Identityhash_map
            = new IdentityHashMap<Integer, String>();
        new_Identityhash_map.putAll(identity_hash);
 
        // Displaying the final IdentityHashMap
        System.out.println("The new map: "
                           + new_Identityhash_map);
    }
}

Initial Mappings are: {10=Geeks, 25=Welcomes, 30=You, 20=Geeks, 15=4}
Returned value is: Geeks
New map is: {10=Geeks, 25=Welcomes, 30=You, 20=All, 15=4}
The new map: {10=Geeks, 25=Welcomes, 30=You, 20=All, 15=4}

2. Eliminación de elementos
Para eliminar asignaciones, usamos remove() , un método incorporado de la clase IdentityHashMap, y se usa para eliminar la asignación de cualquier clave particular del mapa.

// Java code to illustrate removing
// elements from IdentityHashMap
 
import java.util.*;
 
public class RemovingMappingsFromIdentityHashMap {
    public static void main(String[] args)
    {
 
        // Creating an empty IdentityHashMap
        Map<Integer, String> Identity_hash = new
                    IdentityHashMap<Integer, String>();
     
        // Mapping string values to int keys
        Identity_hash.put(10, "Geeks");
        Identity_hash.put(15, "4");
        Identity_hash.put(20, "Geeks");
        Identity_hash.put(25, "Welcomes");
        Identity_hash.put(30, "You");
 
        // Displaying the IdentityHashMap
        System.out.println("Initial Mappings are: " +
                                        Identity_hash);
 
        // Removing the existing key mapping
        String returned_value =
                        (String)Identity_hash.remove(20);
 
        // Verifying the returned value
        System.out.println("Returned value is: " +
                                    returned_value);
 
        // Displaying the new map
        System.out.println("New map is: " + Identity_hash);
    }
}

Initial Mappings are: {10=Geeks, 25=Welcomes, 30=You, 20=Geeks, 15=4}
Returned value is: Geeks
New map is: {10=Geeks, 25=Welcomes, 30=You, 15=4}

3. Accediendo a los Elementos

Podemos acceder a los elementos de un IdentityHashMap usando el método get() , el ejemplo de esto se da a continuación.

// Java code to illustrate the accessing
// elements from IdentityHashMap
 
import java.util.*;
 
public class AccessingElementsFromIdentityHashMap {
 
    public static void main(String[] args)
    {
 
        // Creating an empty IdentityHashMap
        Map<Integer, String> identity_hash
            = new IdentityHashMap<Integer, String>();
 
        // Mapping string values to int keys
        identity_hash.put(10, "Geeks");
        identity_hash.put(15, "4");
        identity_hash.put(20, "Geeks");
        identity_hash.put(25, "Welcomes");
        identity_hash.put(30, "You");
 
        // Displaying the IdentityHashMap
        System.out.println("Initial Mappings are: "
                           + identity_hash);
 
        // Getting the value of 25
        System.out.println("The Value is: "
                           + identity_hash.get(25));
 
        // Getting the value of 10
        System.out.println("The Value is: "
                           + identity_hash.get(10));
       
          // Using keySet() to get the set view of keys
        System.out.println("The set is: " + identity_hash.keySet());
           
          // Using entrySet() to get the set view
        System.out.println("The set is: " +
                                identity_hash.entrySet());
    }
}

Initial Mappings are: {10=Geeks, 25=Welcomes, 30=You, 20=Geeks, 15=4}
The Value is: Welcomes
The Value is: Geeks
The set is: [10, 25, 30, 20, 15]
The set is: [10=Geeks, 25=Welcomes, 30=You, 20=Geeks, 15=4]

4. Atravesar
Podemos usar la interfaz Iterator para atravesar cualquier estructura del marco de la colección. Dado que los iteradores trabajan con un tipo de datos, usamos Entry< ? , ? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next(), imprimimos los elementos del IdentityHashMap.

// Java code to illustrate the
// iterating over IdentityHashmap
 
import java.util.*;
 
public class IteratingIdentityHashMap {
 
    public static void main(String[] args)
    {
 
        // Creating an empty IdentityHashMap
        IdentityHashMap<Integer, String> identity_hash
            = new IdentityHashMap<Integer, String>();
 
        // Mapping string values to int keys
        identity_hash.put(10, "Geeks");
        identity_hash.put(15, "4");
        identity_hash.put(20, "Geeks");
        identity_hash.put(25, "Welcomes");
        identity_hash.put(30, "You");
 
        // Displaying the IdentityHashMap
        System.out.println("Initial Mappings are: "
                           + identity_hash);
 
        // Create an Iterator over the
        // IdentityHashMap
        Iterator<IdentityHashMap.Entry<Integer, String> >
            itr = identity_hash.entrySet().iterator();
 
        // The 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());
        }
    }
}

Initial Mappings are: {10=Geeks, 25=Welcomes, 30=You, 20=Geeks, 15=4}
Key = 10, Value = Geeks
Key = 25, Value = Welcomes
Key = 30, Value = You
Key = 20, Value = Geeks
Key = 15, Value = 4

IdentityHashMap sincronizado

Si varios subprocesos acceden a un mapa hash de identidad al mismo tiempo y al menos uno de los subprocesos modifica el mapa estructuralmente, debe sincronizarse externamente. (Una modificación estructural es cualquier operación que agrega o elimina una o más asignaciones; simplemente cambiar el valor asociado con una clave que ya contiene una instancia no es una modificación estructural). Esto generalmente se logra mediante la sincronización en algún objeto que encapsula naturalmente el mapa . Si no existe tal objeto, el mapa debe «envolverse» utilizando el método Collections.synchronizedMap . Es mejor hacerlo en el momento de la creación, para evitar el acceso no sincronizado accidental al mapa. 

Mapa m = Collections.synchronizedMap(new IdentityHashMap(…));

Métodos de IdentityHashMap

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Métodos declarados en la clase java.util.AbstractMap

Métodos declarados en la interfaz java.util.Map

IdentityHashMap frente  a HashMap

• IdentityHashMap usa el operador de igualdad “==” para comparar claves y valores, mientras que HashMap usa el método de igualdad para comparar claves y valores dentro de Map.
• Dado que IdentityHashMap no usa equals(), es comparativamente más rápido que HashMap para un objeto con equals() costoso.
• IdentityHashMap no requiere que las claves sean inmutables, ya que no se basa en equals().

El siguiente programa ilustra la diferencia entre la implementación de IdentityHashMap y HashMap.

// Java code to demonstrate IdentityHashMap and
// illustration of how it is different from HashMap
 
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;
 
public class IdentityHashMapExample
{
    public static void main(String[] args)
    {
        // Creating HashMap and IdentityHashMap objects
        Map<String, String> hm = new HashMap<>();
        Map<String, String> ihm = new IdentityHashMap<>();
 
        // Putting key and value in HashMap and IdentityHashMap Object
        hm.put("hmkey","hmvalue");
        hm.put(new String("hmkey"),"hmvalue1");
        ihm.put("ihmkey","ihmvalue");
        ihm.put(new String("ihmkey"),"ihmvalue1");
         
        // Print Size of HashMap and WeakHashMap Object
        // 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());
 
         
    }
}

Size of HashMap is : 1
Size of IdentityHashMap is : 2

Este artículo es una contribución de Pratik Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.