El IdentityHashMap implements Mapa utilitzant la interfície Taula hash utilitzant la igualtat de referència en lloc de la igualtat d'objectes en comparar claus (i valors). Aquesta classe no és una implementació de Map de propòsit general. Tot i que aquesta classe implementa la interfície de Map, viola intencionadament el contracte general de Map que obliga a utilitzar el mètode equals() quan es comparen objectes. Aquesta classe s'utilitza quan l'usuari requereix que es comparen els objectes mitjançant referència. Pertany a java.util paquet.

Característiques d'IdentityHashMap

• Segueix la igualtat de referència en lloc d'utilitzar el mètode equals(), utilitza l'operador ==.
• No està sincronitzat i s'ha de sincronitzar externament.
• Els iteradors són un llançament ràpid ConcurrentModificationException en un intent de modificar durant la iteració.
• Aquesta classe proporciona un rendiment en temps constant per a les operacions bàsiques (obtenir i posar) assumint que la funció hash d'identitat del sistema (System.identityHashCode(Object)) dispersa els elements correctament entre els cubs. IdentityHashMap no utilitza el mètode hashCode() sinó que utilitza el mètode System.identityHashCode(). Aquesta és una diferència significativa perquè ara podeu utilitzar objectes mutables com a clau a Map, el codi hash dels quals és probable que canviï quan el mapeig s'emmagatzemi a IdentityHashMap.

Declaració:

classe pública IdentityHashMapamplia AbstractMapimplementa el mapaSerialitzable Clonable 
 

Aquí K és el tipus d'objecte clau i V és el valor Tipus d'objecte.

A Java, IdentityHashMap és una classe que implementa la interfície Map. És similar a la classe HashMap amb la diferència principal és que IdentityHashMap utilitza la igualtat de referència en lloc de la igualtat d'objectes quan es comparen claus.

Mentre que HashMap utilitza el mètode equals() per comparar les claus, IdentityHashMap utilitza l'operador == per comparar les claus. Això vol dir que en un IdentityHashMap dues claus es consideren iguals si i només si són el mateix objecte en lloc de ser iguals pel que fa al seu contingut.

fizzbuzz java

Aquí teniu un exemple de com podeu utilitzar un IdentityHashMap a 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  } } 

sortida;

2 

1

La classe IdentityHashMap a Java és una implementació basada en taules hash de la interfície Map que utilitza la igualtat de referència en lloc de la igualtat d'objectes quan es comparen claus (i valors).

Avantatges d'utilitzar IdentityHashMap sobre HashMap:

1. Cerques més ràpides: com que IdentityHashMap utilitza la igualtat de referència per a la comparació, és més ràpid per a les cerques en comparació amb HashMap que utilitza la igualtat d'objectes.
2. Útil per comparar instàncies d'objectes: IdentityHashMap és útil en situacions en què voleu comparar instàncies d'objectes en lloc de valors d'objectes.

Desavantatges d'utilitzar IdentityHashMap:

1. Utilitza més memòria: IdentityHashMap utilitza més memòria en comparació amb HashMap, ja que necessita emmagatzemar la referència a l'objecte.
2. No apte per a tots els casos d'ús: IdentityHashMap no és adequat per a tots els casos d'ús i s'ha d'utilitzar amb precaució, ja que pot provocar un comportament inesperat en determinades situacions.

La jerarquia d'IdentityHashMap

S'implementa Serialitzable Clonable Mapa interfícies i s'estén Mapa abstracte classe.

Exemple:

// 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 

Constructors d'IdentityHashMap

Podem crear una instància de IdentityHashMap de dues maneres:

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

1. IdentityHashMap():  Construeix un nou mapa hash d'identitat buit amb una mida màxima esperada per defecte. 

IdentityHashMapell = nou IdentityHashMap();

iteració del mapa java

2. IdentityHashMap(int expectedMaxSize):  Construeix un mapa buit nou amb la mida màxima esperada especificada. 

IdentityHashMapihm = new IdentityHashMap(int expectatedMaxSize);

3. IdentityHashMap (Mapa m):  Construeix un mapa hash d'identitat nou que conté les assignacions de valor-clau al mapa especificat.

IdentityHashMapihm = nou IdentityHashMap (Mapa m);

Operacions bàsiques a IdentityHashMap

1. Addició d'elements

Per inserir o afegir mapeig a un IdentityHashMap tenim posar() i posar-ho tot() mètodes. put() pot inserir una clau específica i el valor que està assignant a un mapa concret. Si es passa una clau existent, el valor anterior se substitueix pel valor nou. putAll() copia tots els elements, és a dir, els mapes d'un mapa a un altre. 

// 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ó d'elements
Per eliminar mapes fem servir eliminar () un mètode integrat de la classe IdentityHashMap i s'utilitza per eliminar el mapatge de qualsevol clau 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. Accés als Elements

Podem accedir als elements d'un IdentityHashMap mitjançant el obtenir() mètode, l'exemple d'això es mostra a continuació.

// 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. Travessant
Podem utilitzar la interfície Iterator per recórrer qualsevol estructura del marc de col·lecció. Com que els iteradors treballen amb un tipus de dades, utilitzem Entry< ? ? >per resoldre els dos tipus separats en un format compatible. A continuació, utilitzant el mètode next() imprimim els elements de l'IdentityHashMap.

java int a cadena

// 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 sincronitzat

Si diversos fils accedeixen a un mapa hash d'identitat simultàniament i almenys un dels fils modifica el mapa estructuralment, s'ha de sincronitzar externament. (Una modificació estructural és qualsevol operació que afegeix o elimina una o més mapes; només canviar el valor associat a una clau que ja conté una instància no és una modificació estructural.) Això s'aconsegueix normalment sincronitzant-se en algun objecte que encapsula el mapa de manera natural. Si no existeix aquest objecte, el mapa s'hauria d'"embolicar" amb l' Col·leccions.synchronizedMap mètode. Això es fa millor en el moment de la creació per evitar l'accés accidental no sincronitzat al mapa. 

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

Mètodes d'IdentityHashMap

K– El tipus de claus del mapa.V– El tipus de valors assignats al mapa.

Mètodes declarats a la classe java.util.AbstractMap

Mètodes declarats a la interfície java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap utilitza l'operador d'igualtat '==' per comparar claus i valors, mentre que HashMap utilitza el mètode equals per comparar claus i valors dins de Map.
• Com que IdentityHashMap no utilitza equals(), és relativament més ràpid que HashMap per a un objecte amb equals() car.
• IdentityHashMap no requereix que les claus siguin immutables, ja que no es basa en equals().

El programa següent il·lustra la diferència entre la implementació d'IdentityHashMap i 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 és una classe en Java que implementa la interfície Map i utilitza la igualtat de referència per comparar claus. És similar a un HashMap normal, però utilitza l'operador == per comparar claus en lloc del mètode equals(). Això vol dir que dues claus amb el mateix contingut però diferents referències a objectes es tractaran com a claus diferents en un IdentityHashMap.

Aquí teniu un exemple de com utilitzar IdentityHashMap a 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 aquest exemple creem un IdentityHashMap que mapeja les claus de cadena amb valors enters. Afegim dos parells clau-valor al mapa utilitzant dos objectes String diferents que tenen el mateix contingut. A continuació, recuperem valors del mapa utilitzant els mateixos objectes String i diferents. Trobem que podem recuperar valors del mapa utilitzant les dues claus diferents que tenen el mateix contingut, però no podem recuperar un valor amb un objecte String que tingui el mateix contingut però sigui una referència d'objecte diferent.

Tingueu en compte que IdentityHashMap té un comportament lleugerament diferent d'un HashMap normal i, generalment, només és útil en determinades situacions on la igualtat de referència és important. En la majoria dels casos, un HashMap normal és suficient i més adequat.

c booleà