CLASA IDENTITYHASHMAP ÎN JAVA

The IdentityHashMap unelte Hartă folosind interfata Hashtable utilizarea egalității de referință în locul egalității obiectelor atunci când se compară cheile (și valorile). Această clasă nu este o implementare Map cu scop general. În timp ce această clasă implementează interfața Map, încalcă în mod intenționat contractul general Map care impune utilizarea metodei equals() atunci când se compară obiecte. Această clasă este utilizată atunci când utilizatorul cere ca obiectele să fie comparate prin referință. Ii apartine java.util pachet.

Caracteristicile IdentityHashMap

Urmează egalitatea de referință în loc să folosească metoda equals(), folosește operatorul ==.
Nu este sincronizat și trebuie să fie sincronizat extern.
Iteratoarele sunt aruncări rapide ConcurrentModificationException într-o încercare de modificare în timpul iterării.
Această clasă oferă performanță în timp constant pentru operațiunile de bază (obținere și introducere) presupunând că funcția hash de identitate a sistemului (System.identityHashCode(Object)) dispersează elementele în mod corespunzător printre găleți. IdentityHashMap nu folosește metoda hashCode(), ci folosește metoda System.identityHashCode(). Aceasta este o diferență semnificativă, deoarece acum puteți utiliza obiecte mutabile ca cheie în Map al căror cod hash este probabil să se schimbe atunci când maparea este stocată în IdentityHashMap.

Declaraţie:

clasă publică IdentityHashMap extinde AbstractMap implementează Harta Serializabil Clonabil

Aici K este tipul de obiect cheie și V este valoarea Object type.

În Java, IdentityHashMap este o clasă care implementează interfața Map. Este similar cu clasa HashMap, principala diferență fiind că IdentityHashMap folosește egalitatea referințelor în loc de egalitatea obiectelor atunci când compară cheile.

În timp ce HashMap folosește metoda equals() pentru a compara cheile, IdentityHashMap folosește operatorul == pentru a compara cheile. Aceasta înseamnă că într-un IdentityHashMap două chei sunt considerate egale dacă și numai dacă sunt același obiect, mai degrabă decât să fie egale în ceea ce privește conținutul lor.

Iată un exemplu despre cum ați putea folosi un IdentityHashMap în 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      }   }

ieșire;

Clasa IdentityHashMap în Java este o implementare bazată pe tabel hash a interfeței Map care utilizează egalitatea referințelor în loc de egalitatea obiectelor atunci când compară cheile (și valorile).

Avantajele utilizării IdentityHashMap față de HashMap:

Căutări mai rapide: Deoarece IdentityHashMap folosește egalitatea de referință pentru comparație, este mai rapidă pentru căutări în comparație cu HashMap care utilizează egalitatea obiectelor.
Util pentru compararea instanțelor obiectului: IdentityHashMap este utilă în situațiile în care doriți să comparați instanțele obiectului, mai degrabă decât valorile obiectului.

Dezavantajele utilizării IdentityHashMap:

Utilizează mai multă memorie: IdentityHashMap utilizează mai multă memorie în comparație cu HashMap, deoarece trebuie să stocheze referința la obiect.
Nu este potrivit pentru toate cazurile de utilizare: IdentityHashMap nu este potrivit pentru toate cazurile de utilizare și trebuie utilizat cu precauție, deoarece poate duce la un comportament neașteptat în anumite situații.

Ierarhia IdentityHashMap

IdentityHashMap în Java

Se implementează Serializabil Clonabil Hartă interfețe și se extinde AbstractHarta clasă.

Exemplu:

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

Ieșire

Size of IdentityHashMap--2

Constructorii IdentityHashMap

Putem crea o instanță de IdentityHashMap în două moduri:

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

1. IdentityHashMap(): Construiește o nouă hartă hash de identitate goală cu o dimensiune maximă preconizată implicită.

IdentityHashMap el = noua IdentityHashMap ();

2. IdentityHashMap(int expectedMaxSize): Construiește o nouă hartă goală cu dimensiunea maximă așteptată specificată.

IdentityHashMap ihm = new IdentityHashMap (int waitedMaxSize);

3. IdentityHashMap(Harta m): Construiește o nouă hartă hash de identitate care conține mapările cheie-valoare din harta specificată.

IdentityHashMap ihm = nou IdentityHashMap(Harta m);

Operații de bază pe IdentityHashMap

1. Adăugarea de elemente

Pentru a insera sau adăuga mapare într-un IdentityHashMap avem pune() şi pune tot() metode. put() poate insera o anumită cheie și valoarea pe care o mapează într-o anumită hartă. Dacă o cheie existentă este transmisă, atunci valoarea anterioară este înlocuită cu noua valoare. putAll() copiază toate elementele, adică mapările de pe o hartă în alta.

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

Ieșire

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. Îndepărtarea elementelor
Pentru a elimina mapările pe care le folosim elimina() o metodă încorporată a clasei IdentityHashMap și este folosită pentru a elimina maparea oricărei chei particulare de pe hartă.

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

Ieșire

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

Putem accesa elementele unui IdentityHashMap folosind obţine() metoda, exemplul acesteia este dat mai jos.

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

Ieșire

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. Traversarea
Putem folosi interfața Iterator pentru a parcurge orice structură a cadrului de colectare. Deoarece iteratorii lucrează cu un singur tip de date, folosim Entry < ? ? >pentru a rezolva cele două tipuri separate într-un format compatibil. Apoi folosind metoda next() imprimăm elementele 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  ());      }      }   }

Ieșire

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

Sincronizat IdentityHashMap

Dacă mai multe fire de execuție accesează o hartă hash de identitate simultan și cel puțin unul dintre fire de execuție modifică structura structural, aceasta trebuie sincronizată extern. (O modificare structurală este orice operațiune care adaugă sau șterge una sau mai multe mapări; simpla modificare a valorii asociate cu o cheie pe care o instanță o conține deja nu este o modificare structurală.) Aceasta este de obicei realizată prin sincronizarea pe un obiect care încapsulează în mod natural harta. Dacă nu există un astfel de obiect, harta ar trebui să fie „înfășurată” folosind Colecții.Hartă sincronizată metodă. Cel mai bine se face acest lucru în momentul creării pentru a preveni accesul accidental nesincronizat la hartă.

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

Metode de IdentityHashMap

K – Tipul cheilor din hartă. V – Tipul de valori mapate în hartă.

METODĂ	DESCRIERE
clar()	Elimină toate mapările de pe această hartă.
clona()	Returnează o copie superficială a acestei hărți hash de identitate: cheile și valorile în sine nu sunt clonate.
containsKey? (Cheia obiectului)	Testează dacă referința obiectului specificat este o cheie în această hartă hash de identitate.
containsValue? (Valoare obiect)	Testează dacă referința obiectului specificat este o valoare în această hartă hash de identitate.
entrySet()	Returnează a Set vizualizarea mapărilor conținute în această hartă.
este egal? (Obiect o)	Compară obiectul specificat cu această hartă pentru egalitate.
obține? (cheia obiect)	Returnează valoarea la care este mapată cheia specificată sau nulă dacă această hartă nu conține nicio mapare pentru cheie.
hashCode()	Returnează valoarea codului hash pentru această hartă.
este gol()	Returnează true dacă această hartă hash de identitate nu conține mapări cheie-valoare.
keySet()	Returnează o vedere de set bazată pe identitate a cheilor conținute în această hartă.
pune? (valoarea V tastei K)	Asociază valoarea specificată cu cheia specificată în această hartă hash de identitate.
pune tot? (Harta m)	Copiază toate mapările de pe harta specificată pe această hartă.
eliminați? (cheia obiectului)	Elimină maparea pentru această cheie de pe această hartă, dacă este prezentă.
dimensiune()	Returnează numărul de mapări cheie-valoare din această hartă hash de identitate.
valori ()	Returnează o vizualizare de colecție a valorilor conținute în această hartă.

Metode declarate în clasa java.util.AbstractMap

METODĂ	DESCRIERE
toString()	Returnează o reprezentare șir a acestei hărți.

Metode declarate în interfața java.util.Map

METODĂ	DESCRIERE
calculați? (Tasta K BiFunction funcția de remapare)	Încearcă să calculeze o mapare pentru cheia specificată și valoarea sa mapată curentă (sau nulă dacă nu există o mapare curentă).
computeIfAbsent? (funcția tastei K mappingFunction)	Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null) încearcă să-și calculeze valoarea utilizând funcția de mapare dată și o introduce în această hartă, dacă nu este nulă.
computeIfPresent? (Tasta K BiFunction funcția de remapare)	Dacă valoarea pentru cheia specificată este prezentă și non-null încearcă să calculeze o nouă mapare având în vedere cheia și valoarea sa mapată curentă.
pentru fiecare? (BiConsumer acţiune)	Efectuează acțiunea dată pentru fiecare intrare din această hartă până când toate intrările au fost procesate sau acțiunea aruncă o excepție.
getOrDefault?(Cheia obiect V defaultValue)	Returnează valoarea la care este mapată cheia specificată sau defaultValue dacă această hartă nu conține nicio mapare pentru cheie.
îmbinare? (Tasta K V valoare BiFunction funcția de remapare)	Dacă cheia specificată nu este deja asociată cu o valoare sau este asociată cu null, o asociază cu valoarea non-nulă dată.
putIfAbsent? (Valoare K cheie V)	Dacă cheia specificată nu este deja asociată cu o valoare (sau este mapată la null) o asociază cu valoarea dată și returnează null, altfel returnează valoarea curentă.
eliminați? (Cheie obiect Valoare obiect)	Elimină intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată.
înlocuiți? (Valoarea V a tastei K)	Înlocuiește intrarea pentru cheia specificată numai dacă este mapată în prezent la o anumită valoare.
înlocuiți? (Tasta K V Valoare veche V Valoare nouă)	Înlocuiește intrarea pentru cheia specificată numai dacă este mapată în prezent la valoarea specificată.
înlocuițiToate? (BiFunction funcţie)	Înlocuiește valoarea fiecărei intrări cu rezultatul invocării funcției date pe acea intrare până când toate intrările au fost procesate sau funcția aruncă o excepție.

IdentityHashMap vs HashMap

IdentityHashMap folosește operatorul de egalitate „==” pentru a compara cheile și valorile, în timp ce HashMap utilizează metoda equals pentru a compara cheile și valorile din interiorul Map.
Deoarece IdentityHashMap nu folosește equals(), este relativ mai rapid decât HashMap pentru un obiect cu equals() scump.
IdentityHashMap nu necesită chei pentru a fi imuabile, deoarece nu se bazează pe equals().

Programul de mai jos ilustrează diferența dintre implementarea 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  ());          }   }

Ieșire

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

IdentityHashMap este o clasă în Java care implementează interfața Map și utilizează egalitatea de referință pentru a compara cheile. Este similar cu un HashMap obișnuit, dar folosește operatorul == pentru a compara cheile în loc de metoda equals(). Aceasta înseamnă că două chei cu același conținut, dar referințe diferite la obiect vor fi tratate ca chei distincte într-un IdentityHashMap.

Iată un exemplu de utilizare a IdentityHashMap în 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      }   }

Ieșire

1 2 null

În acest exemplu, creăm un IdentityHashMap care mapează cheile String la valori întregi. Adăugăm două perechi cheie-valoare pe hartă folosind două obiecte String diferite care au același conținut. Apoi recuperăm valorile de pe hartă folosind aceleași și diferite obiecte String. Constatăm că putem prelua valori de pe hartă utilizând cele două chei diferite care au același conținut, dar nu putem prelua o valoare folosind un obiect String care are același conținut, dar este o referință diferită de obiect.

Rețineți că IdentityHashMap are un comportament ușor diferit față de un HashMap obișnuit și este, în general, util doar în anumite situații în care egalitatea de referință este importantă. În cele mai multe cazuri, un HashMap obișnuit este suficient și mai adecvat.

Creați un test