CLASSE IDENTITYHASHMAP A JAVA

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 IdentityHashMap amplia AbstractMap implementa el mapa Serialitzable 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.

Aquí teniu un exemple de com podeu utilitzar un IdentityHashMap a Java:

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;

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:

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.
Ú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:

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

IdentityHashMap a Java

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

Exemple:

Java

    // 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  ());          }   }

Sortida

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.

IdentityHashMap ell = nou IdentityHashMap ();

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

IdentityHashMap ihm = 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.

IdentityHashMap ihm = 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

    // 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  );      }   }

Sortida

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

    // 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  );         }      }

Sortida

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

    // 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  ());         }   }

Sortida

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

    // 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  ());      }      }   }

Sortida

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ÈTODE	DESCRIPCIÓ
clar ()	Elimina tots els mapes d'aquest mapa.
clonar ()	Retorna una còpia superficial d'aquest mapa hash d'identitat: les claus i els valors no es clonen.
containsKey? (clau d'objecte)	Comprova si la referència d'objecte especificada és una clau en aquest mapa hash d'identitat.
containsValue? (Valor de l'objecte)	Comprova si la referència d'objecte especificada és un valor en aquest mapa hash d'identitat.
entrySet()	Retorna a Set visualització dels mapes continguts en aquest mapa.
és igual? (Objecte o)	Compara l'objecte especificat amb aquest mapa per a la igualtat.
obtenir? (clau d'objecte)	Retorna el valor al qual s'assigna la clau especificada o nul si aquest mapa no conté cap assignació per a la clau.
hashCode()	Retorna el valor del codi hash per a aquest mapa.
està buit()	Retorna true si aquest mapa hash d'identitat no conté assignacions de valor-clau.
keySet()	Retorna una vista conjunta basada en la identitat de les claus contingudes en aquest mapa.
posar? (valor de la clau K V)	Associa el valor especificat amb la clau especificada en aquest mapa hash d'identitat.
posar-ho tot? (Mapa m)	Copia tots els mapes del mapa especificat a aquest mapa.
eliminar? (clau d'objecte)	Elimina l'assignació d'aquesta clau d'aquest mapa si n'hi ha.
mida ()	Retorna el nombre de mapes de valor-clau en aquest mapa hash d'identitat.
valors ()	Retorna una vista de col·lecció dels valors continguts en aquest mapa.

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

MÈTODE	DESCRIPCIÓ
toString()	Retorna una representació de cadena d'aquest mapa.

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

MÈTODE	DESCRIPCIÓ
calcular? (tecla K BiFunction funció de reasignació)	Intenta calcular una assignació per a la clau especificada i el seu valor assignat actual (o nul si no hi ha cap assignació actual).
computeIfAbsent? (Funció de la tecla K mappingFunction)	Si la clau especificada encara no està associada amb un valor (o està assignada a nul), prova de calcular-ne el valor mitjançant la funció de mapeig donada i l'introdueix en aquest mapa tret que sigui nul.
computeIfPresent? (tecla K BiFunction funció de reasignació)	Si el valor de la clau especificada està present i no és nul, intenta calcular una nova assignació donada la clau i el seu valor assignat actual.
per a cadascú? (BiConsumer acció)	Realitza l'acció donada per a cada entrada d'aquest mapa fins que s'hagin processat totes les entrades o l'acció produeixi una excepció.
getOrDefault? (clau d'objecte V defaultValue)	Retorna el valor al qual està assignada la clau especificada o defaultValue si aquest mapa no conté cap assignació per a la clau.
combinar? (Valor de la tecla K V BiFunction funció de reasignació)	Si la clau especificada encara no està associada amb un valor o està associada amb nul, l'associa amb el valor no nul donat.
putIfAbsent? (valor V de la clau K)	Si la clau especificada encara no està associada amb un valor (o està assignada a null) l'associa amb el valor donat i retorna null, sinó retorna el valor actual.
eliminar? (Clau d'objecte Valor de l'objecte)	Elimina l'entrada de la clau especificada només si actualment està assignada al valor especificat.
substituir? (valor V de la tecla K)	Substitueix l'entrada de la clau especificada només si actualment està assignada a algun valor.
substituir? (clau K V valor antic V valor nou)	Substitueix l'entrada de la clau especificada només si actualment està assignada al valor especificat.
substituirAll? (BiFunction funció)	Substitueix el valor de cada entrada amb el resultat d'invocar la funció donada en aquesta entrada fins que s'hagin processat totes les entrades o la funció llança una excepció.

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

    // 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  ());          }   }

Sortida

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:

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

Sortida

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.

Crea un qüestionari