El IdentidadHashMap implementos Mapa interfaz usando tabla hash usar igualdad de referencia en lugar de igualdad de objetos al comparar claves (y valores). Esta clase no es una implementación de mapas 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 mediante referencia. pertenece a java.util paquete.

Características de IdentityHashMap

• Sigue la igualdad de referencia en lugar de usar el método igual (), usa el operador ==.
• No está sincronizado y debe sincronizarse externamente.
• Los iteradores son lanzadores rápidos. Excepción de modificación simultánea en un intento de modificar mientras se itera.
• Esta clase proporciona rendimiento en tiempo constante para las operaciones básicas (obtener y colocar), suponiendo que la función hash de identidad del sistema (System.identityHashCode(Object)) dispersa los elementos correctamente entre los depósitos. 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 la asignación se almacene dentro de IdentityHashMap.

Declaración:

clase pública IdentityHashMapextiende AbstractMapimplementos MapaSerializable y clonable 
 

Aquí k es el tipo de objeto clave y V es el valor Tipo de objeto.

En Java IdentityHashMap es una clase que implementa la interfaz Map. Es similar a la clase HashMap con la principal diferencia de que IdentityHashMap usa igualdad de referencia en lugar de igualdad de objetos al comparar claves.

Mientras que HashMap usa el método igual () para comparar las claves, IdentityHashMap usa el operador == para comparar las claves. Esto significa que en un IdentityHashMap dos claves se consideran iguales si y sólo si son el mismo objeto en lugar de ser iguales en términos de su contenido.

rudyard kipling si explicación

A continuación se muestra un ejemplo de cómo se puede utilizar un IdentityHashMap en Java:

import java.util.IdentityHashMap; public class Example {  public static void main(String[] args) {  IdentityHashMap<String Integer> identityHashMap = new IdentityHashMap<>();  identityHashMap.put('A' 1);  identityHashMap.put(new String('A') 2);  System.out.println(identityHashMap.size()); // 2  System.out.println(identityHashMap.get('A')); // 1  } } 

producción;

2 

1

La clase IdentityHashMap en Java es una implementación basada en tabla hash de la interfaz Map que utiliza igualdad de referencia en lugar de igualdad de objetos al comparar claves (y valores).

Ventajas de usar IdentityHashMap sobre HashMap:

1. Búsquedas más rápidas: dado que IdentityHashMap usa igualdad de referencia para comparar, las búsquedas son más rápidas en comparación con HashMap, que usa igualdad de objetos.
2. Útil para comparar instancias de objetos: IdentityHashMap es útil en situaciones en las que desea comparar instancias de objetos en lugar de valores de objetos.

Desventajas de usar IdentityHashMap:

1. Utiliza más memoria: IdentityHashMap utiliza más memoria en comparación con HashMap, ya que necesita almacenar la referencia al objeto.
2. No apto para todos los casos de uso: IdentityHashMap no es adecuado para todos los casos de uso y debe utilizarse con precaución, ya que puede provocar comportamientos inesperados en determinadas situaciones.

La jerarquía de IdentityHashMap

implementa Serializable Clonable Mapa interfaces y se extiende ResumenMapa clase.

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 IdentidadHashMap de dos maneras:

IdentityHashMap ihm = new IdentityHashMap(); (or) Map hm = new IdentityHashMap();

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

IdentidadHashMapél = nuevo IdentityHashMap();

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

IdentidadHashMapihm = nuevo IdentityHashMap(int esperadoMaxSize);

programas de Python

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

IdentidadHashMapihm = nuevo IdentityHashMap(Mapa m);

Operaciones básicas en IdentityHashMap

1. Agregar elementos

tipos de red

Para insertar o agregar mapeo en un IdentityHashMap tenemos poner() y ponerTodo() métodos. put() puede insertar una clave específica y el valor que está asignando 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: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes 20=All} The new map: {30=You 10=Geeks 15=4 25=Welcomes 20=All} 

2. Eliminación de elementos
Para eliminar asignaciones utilizamos eliminar() un método incorporado de la clase IdentityHashMap y se utiliza para eliminar la asignación de cualquier clave en 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: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Returned value is: Geeks New map is: {30=You 10=Geeks 15=4 25=Welcomes} 

3. Accediendo a los Elementos

Podemos acceder a los elementos de un IdentityHashMap usando el conseguir() método, 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: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} The Value is: Welcomes The Value is: Geeks The set is: [30 10 15 25 20] The set is: [30=You 10=Geeks 15=4 25=Welcomes 20=Geeks] 

4. Atravesando
Podemos usar la interfaz Iterator para recorrer cualquier estructura del Collection Framework. Dado que los iteradores trabajan con un tipo de datos, utilizamos Entry< ? ? >para resolver los dos tipos separados en un formato compatible. Luego, usando el método next() imprimimos los elementos de 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: {30=You 10=Geeks 15=4 25=Welcomes 20=Geeks} Key = 30 Value = You Key = 10 Value = Geeks Key = 15 Value = 4 Key = 25 Value = Welcomes Key = 20 Value = Geeks 

IdentityHashMap sincronizado

Si varios subprocesos acceden a un mapa de hash de identidad al mismo tiempo y al menos uno de los subprocesos modifica estructuralmente el mapa, 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 una instancia ya contiene no es una modificación estructural). Esto generalmente se logra mediante la sincronización en algún objeto que encapsule naturalmente el mapa. Si no existe tal objeto, el mapa debe "ajustarse" usando el Colecciones.mapa sincronizado método. Es mejor hacerlo en el momento de la creación para evitar el acceso accidental y no sincronizado 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 asignados en el mapa.

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

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

IdentityHashMap y  HashMap

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

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 

IdentityHashMap es una clase en Java que implementa la interfaz Map y utiliza igualdad de referencia para comparar claves. Es similar a un HashMap normal pero utiliza el operador == para comparar claves en lugar del método equals(). Esto significa que dos claves con el mismo contenido pero diferentes referencias de objetos se tratarán como claves distintas en un IdentityHashMap.

Aquí hay un ejemplo de cómo usar IdentityHashMap en Java:

import java.util.IdentityHashMap; public class IdentityHashMapExample {  public static void main(String[] args) {  IdentityHashMap<String Integer> map = new IdentityHashMap<>();  // Add key-value pairs to the map  String key1 = new String('key');  String key2 = new String('key');  map.put(key1 1);  map.put(key2 2);  // Get values from the map using the same and different keys  System.out.println(map.get(key1)); // Output: 1  System.out.println(map.get(key2)); // Output: 2  System.out.println(map.get(new String('key'))); // Output: null  } } 

1 2 null 

En este ejemplo, creamos un IdentityHashMap que asigna claves de cadena a valores enteros. Agregamos dos pares clave-valor al mapa usando dos objetos String diferentes que tienen el mismo contenido. Luego recuperamos valores del mapa usando los mismos y diferentes objetos String. Descubrimos que podemos recuperar valores del mapa usando dos claves diferentes que tienen el mismo contenido, pero no podemos recuperar un valor usando un objeto String que tiene el mismo contenido pero es una referencia de objeto diferente.

Tenga en cuenta que IdentityHashMap tiene un comportamiento ligeramente diferente al de un HashMap normal y, por lo general, solo es útil en determinadas situaciones en las que la igualdad de referencias es importante. En la mayoría de los casos, un HashMap normal es suficiente y más apropiado.

un millón en números