IDENTITYHASHMAP KLASE JAVA

The IdentityHashMap īsteno Karte interfeisa izmantošana Hashtable izmantojot atsauces vienlīdzību objekta vienlīdzības vietā, salīdzinot atslēgas (un vērtības). Šī klase nav vispārējas nozīmes kartes ieviešana. Lai gan šī klase ievieš kartes saskarni, tā apzināti pārkāpj Map vispārējo līgumu, kas nosaka, ka, salīdzinot objektus, ir jāizmanto vienāds() metode. Šī klase tiek izmantota, ja lietotājs pieprasa objektus salīdzināt, izmantojot atsauci. Tas pieder java.util iepakojums.

IdentityHashMap funkcijas

Tas seko atsauces vienlīdzībai, nevis izmanto equals() metodi, bet izmanto == operatoru.
Tas nav sinhronizēts, un tas ir jāsinhronizē ārēji.
Iteratori ir ātrs metiens ConcurrentModificationException mēģinot mainīt atkārtošanas laikā.
Šī klase nodrošina pastāvīgu veiktspēju pamata operācijām (iegūt un ievietot), pieņemot, ka sistēmas identitātes jaucējfunkcija (System.identityHashCode(Object)) pareizi izkliedē elementus starp segmentiem. IdentityHashMap neizmanto metodi hashCode(), tā vietā tā izmanto metodi System.identityHashCode(). Tā ir būtiska atšķirība, jo tagad kā atslēgu kartē varat izmantot maināmus objektus, kuru jaucējkods, visticamāk, mainīsies, kad kartēšana tiek saglabāta IdentityHashMap.

Deklarācija:

publiskās klases IdentityHashMap paplašina AbstractMap ievieš karti Serializējams klonējams

Šeit K ir galvenais Objekta veids un V ir vērtība Objekta tips.

Java IdentityHashMap ir klase, kas ievieš kartes saskarni. Tas ir līdzīgs HashMap klasei, un galvenā atšķirība ir tāda, ka, salīdzinot atslēgas, IdentityHashMap izmanto atsauces vienādību, nevis objektu vienlīdzību.

Lai gan HashMap atslēgu salīdzināšanai izmanto metodi equals(), IdentityHashMap izmanto == operatoru, lai salīdzinātu atslēgas. Tas nozīmē, ka IdentityHashMap divas atslēgas tiek uzskatītas par vienādām tad un tikai tad, ja tās ir viens un tas pats objekts, nevis vienādas satura ziņā.

Šeit ir piemērs tam, kā Java var izmantot IdentityHashMap:

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

izvade;

IdentityHashMap klase Java ir uz jaucējtabulu balstīta kartes interfeisa implementācija, kas, salīdzinot atslēgas (un vērtības), izmanto atsauces vienlīdzību objekta vienlīdzības vietā.

IdentityHashMap izmantošanas priekšrocības salīdzinājumā ar HashMap:

Ātrāka meklēšana: tā kā IdentityHashMap salīdzināšanai izmanto atsauces vienlīdzību, meklēšana ir ātrāka salīdzinājumā ar HashMap, kas izmanto objektu vienlīdzību.
Noderīga objektu gadījumu salīdzināšanai: IdentityHashMap ir noderīga situācijās, kad vēlaties salīdzināt objektu gadījumus, nevis objektu vērtības.

IdentityHashMap izmantošanas trūkumi:

Izmanto vairāk atmiņas: IdentityHashMap izmanto vairāk atmiņas salīdzinājumā ar HashMap, jo tai ir jāsaglabā atsauce uz objektu.
Nav piemērots visiem lietošanas gadījumiem: IdentityHashMap nav piemērots visiem lietošanas gadījumiem, un tas jāizmanto piesardzīgi, jo tas var izraisīt neparedzētu rīcību noteiktās situācijās.

IdentityHashMap hierarhija

IdentityHashMap Java

Tā īsteno Serializējams Klonējams Karte saskarnes un paplašina AbstractMap klasē.

Piemērs:

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

Izvade

Size of IdentityHashMap--2

IdentityHashMap konstruktori

Mēs varam izveidot piemēru IdentityHashMap divos veidos:

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

1. IdentityHashMap(): Izveido jaunu tukšu identitātes jaucējkarti ar noklusējuma paredzamo maksimālo izmēru.

IdentityHashMap viņam = jauna IdentityHashMap ();

2. IdentityHashMap(int expectMaxSize): Izveido jaunu tukšu karti ar norādīto paredzamo maksimālo izmēru.

IdentityHashMap ihm = new IdentityHashMap(int gaidītsMaxSize);

3. IdentityHashMap (karte m): Izveido jaunu identitātes jaucējkarti, kas satur atslēgas vērtību kartējumus norādītajā kartē.

IdentityHashMap ihm = new IdentityHashMap(Karte m);

IdentityHashMap pamatoperācijas

1. Elementu pievienošana

Lai ievietotu vai pievienotu kartējumu IdentityHashMap, kas mums ir likt () un likt visu() metodes. put() var ievietot noteiktu atslēgu un vērtību, ko tā kartē, noteiktā kartē. Ja tiek nodota esošā atslēga, iepriekšējā vērtība tiek aizstāta ar jauno vērtību. PutAll () kopē visus elementus, t.i., kartējumus no vienas kartes citā.

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

Izvade

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. Elementu noņemšana
Mēs izmantojam kartējumu noņemšanai noņemt () IdentityHashMap klases iebūvēta metode un tiek izmantota, lai noņemtu jebkuras noteiktas atslēgas kartēšanu no kartes.

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

Izvade

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. Piekļuve elementiem

Mēs varam piekļūt IdentityHashMap elementiem, izmantojot saņemt () metodes piemērs ir sniegts zemāk.

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

Izvade

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. Traversēšana
Mēs varam izmantot Iterator saskarni, lai pārvietotos pa jebkuru kolekcijas ietvara struktūru. Tā kā iteratori strādā ar viena veida datiem, mēs izmantojam Entry < ? ? >lai atrisinātu abus atsevišķos veidus saderīgā formātā. Pēc tam, izmantojot next() metodi, mēs izdrukājam IdentityHashMap elementus.

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

Izvade

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

Sinhronizēta IdentityHashMap

Ja vairāki pavedieni vienlaikus piekļūst identitātes jaucējkartei un vismaz viens no pavedieniem strukturāli modificē karti, tas ir jāsinhronizē ārēji. (Strukturāla modifikācija ir jebkura darbība, kas pievieno vai dzēš vienu vai vairākus kartējumus; tikai ar instancē jau ietverto atslēgu saistītās vērtības mainīšana nav strukturāla modifikācija.) To parasti veic, sinhronizējot kādu objektu, kas dabiski iekapsulē karti. Ja šāda objekta nav, karte ir jāietver, izmantojot Collections.synchronizedMap metodi. To vislabāk var izdarīt izveides laikā, lai novērstu nejaušu nesinhronizētu piekļuvi kartei.

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

IdentityHashMap metodes

K – taustiņu veids kartē. V – kartē kartēto vērtību veids.

METODE	APRAKSTS
skaidrs ()	No šīs kartes tiek noņemti visi kartējumi.
klons ()	Atgriež šīs identitātes jaucējkartes seklu kopiju: pašas atslēgas un vērtības netiek klonētas.
includeKey? (Objekta atslēga)	Pārbauda, vai norādītā objekta atsauce ir atslēga šajā identitātes jaucējkartē.
includeValue?(Objekta vērtība)	Pārbauda, vai norādītā objekta atsauce ir vērtība šajā identitātes jaucējkartē.
ierakstsSet()	Atgriež a Iestatīt šajā kartē ietverto kartējumu skats.
vienāds? (Objekts o)	Vienlīdzības labad salīdzina norādīto objektu ar šo karti.
iegūt? (Objekta atslēga)	Atgriež vērtību, kurai norādītā atslēga ir kartēta, vai nulli, ja šajā kartē nav atslēgas kartējuma.
hashCode()	Atgriež šīs kartes jaucējkoda vērtību.
ir tukšs()	Atgriež vērtību True, ja šajā identitātes jaucējkartē nav atslēgu un vērtību kartējumu.
keySet()	Atgriež uz identitāti balstītu šajā kartē ietverto atslēgu kopas skatu.
likt? (K atslēgas V vērtība)	Saista norādīto vērtību ar norādīto atslēgu šajā identitātes jaucējkartē.
ielikt visu? (Karte m)	Kopē visus kartējumus no norādītās kartes uz šo karti.
noņemt? (Objekta atslēga)	Noņem šīs atslēgas kartējumu no šīs kartes, ja tāda ir.
izmērs ()	Atgriež atslēgas vērtību kartējumu skaitu šajā identitātes jaucējkartē.
vērtības ()	Atgriež šajā kartē ietverto vērtību kolekcijas skatu.

Klasē java.util.AbstractMap deklarētās metodes

METODE	APRAKSTS
toString()	Atgriež šīs kartes virknes attēlojumu.

Interfeisā java.util.Map deklarētās metodes

METODE	APRAKSTS
aprēķināt? (K taustiņš BiFunction remappingFunction)	Mēģina aprēķināt kartējumu norādītajai atslēgai un tās pašreizējai kartētajai vērtībai (vai nullei, ja pašreizējā kartējuma nav).
computeIfAbsent?(K taustiņa Funkcija kartēšanas funkcija)	Ja norādītā atslēga vēl nav saistīta ar vērtību (vai ir kartēta uz nulli), mēģina aprēķināt tās vērtību, izmantojot doto kartēšanas funkciju, un ievada to šajā kartē, ja vien nav nulles.
computeIfPresent? (K taustiņš BiFunction remappingFunction)	Ja norādītās atslēgas vērtība ir un nav nulle, mēģina aprēķināt jaunu kartējumu, ņemot vērā atslēgu un tās pašreizējo kartēto vērtību.
katram? (BiConsumer darbība)	Veic norādīto darbību katram ierakstam šajā kartē, līdz visi ieraksti ir apstrādāti vai darbība rada izņēmumu.
getOrDefault?(Objekta atslēga V noklusējuma vērtība)	Atgriež vērtību, ar kuru norādītā atslēga ir kartēta, vai noklusējuma vērtību, ja šajā kartē nav atslēgas kartējuma.
sapludināt? (K taustiņa V vērtība BiFunction remappingFunction)	Ja norādītā atslēga vēl nav saistīta ar vērtību vai ir saistīta ar nulli, tā saista to ar norādīto vērtību, kas nav nulles.
putJaNav?(K atslēgas V vērtība)	Ja norādītā atslēga vēl nav saistīta ar vērtību (vai ir kartēta uz nulli), tā saista to ar norādīto vērtību un atgriež nulli. else atgriež pašreizējo vērtību.
noņemt? (Objekta atslēga Objekta vērtība)	Noņem norādītās atslēgas ierakstu tikai tad, ja tas pašlaik ir kartēts ar norādīto vērtību.
aizstāt? (K atslēgas V vērtība)	Aizstāj norādītās atslēgas ierakstu tikai tad, ja tā pašlaik ir saistīta ar kādu vērtību.
aizstāt? (K taustiņš V oldValue V newValue)	Aizstāj norādītās atslēgas ierakstu tikai tad, ja pašlaik tas ir kartēts ar norādīto vērtību.
aizstāt visu? (BiFunction funkcija)	Aizstāj katra ieraksta vērtību ar norādītās funkcijas izsaukšanas rezultātu šajā ierakstā, līdz visi ieraksti ir apstrādāti vai funkcija rada izņēmumu.

IdentityHashMap vs HashMap

IdentityHashMap izmanto vienlīdzības operatoru '==', lai salīdzinātu atslēgas un vērtības, savukārt HashMap izmanto vienādības metodi, lai salīdzinātu atslēgas un vērtības programmā Map.
Tā kā IdentityHashMap neizmanto equals(), tas ir salīdzinoši ātrāks nekā HashMap objektam ar dārgu vienādojumu ().
IdentityHashMap neprasa, lai atslēgas būtu nemainīgas, jo tā netiek paļauta uz equals ().

Tālāk redzamā programma ilustrē atšķirību starp IdentityHashMap un HashMap ieviešanu.

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

Izvade

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

IdentityHashMap ir Java klase, kas ievieš kartes saskarni un izmanto atsauces vienlīdzību, lai salīdzinātu atslēgas. Tas ir līdzīgs parastajam HashMap, taču tas izmanto == operatoru, lai salīdzinātu atslēgas, nevis vienādu () metodi. Tas nozīmē, ka divas atslēgas ar tādu pašu saturu, bet atšķirīgām objektu atsaucēm tiks uzskatītas par atšķirīgām atslēgām IdentityHashMap.

Šeit ir piemērs, kā izmantot IdentityHashMap 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      }   }

Izvade

1 2 null

Šajā piemērā mēs izveidojam IdentityHashMap, kas kartē virknes atslēgas ar veselu skaitļu vērtībām. Mēs pievienojam kartei divus atslēgu-vērtību pārus, izmantojot divus dažādus virknes objektus, kuriem ir vienāds saturs. Pēc tam mēs izgūstam vērtības no kartes, izmantojot tos pašus un dažādus virknes objektus. Mēs atklājam, ka mēs varam izgūt vērtības no kartes, izmantojot divas dažādas atslēgas, kurām ir vienāds saturs, bet mēs nevaram izgūt vērtību, izmantojot String objektu, kuram ir tāds pats saturs, bet kas ir cita objekta atsauce.

Ņemiet vērā, ka IdentityHashMap darbība nedaudz atšķiras no parastās HashMap un parasti ir noderīga tikai noteiktās situācijās, kad ir svarīga atsauces vienlīdzība. Vairumā gadījumu parastā HashMap ir pietiekama un piemērotāka.

Izveidojiet viktorīnu