IDENTITYHASHMAP-KLASSEN I JAVA

De IdentityHashMap redskaper Kart grensesnitt ved hjelp av Hastbar ved å bruke referanselikhet i stedet for objektlikhet når man sammenligner nøkler (og verdier). Denne klassen er ikke en generell kartimplementering. Mens denne klassen implementerer Map-grensesnittet, bryter den med hensikt Maps generelle kontrakt som krever bruk av equals()-metoden ved sammenligning av objekter. Denne klassen brukes når brukeren krever at objektene skal sammenlignes via referanse. Det tilhører java.util pakke.

Funksjoner av IdentityHashMap

Den følger referanselikhet i stedet for å bruke equals()-metoden, den bruker ==-operatoren.
Den er ikke synkronisert og må synkroniseres eksternt.
Iteratorer er feil-raske kast ConcurrentModificationException i et forsøk på å endre mens du itererer.
Denne klassen gir konstant-tidsytelse for de grunnleggende operasjonene (get og put) forutsatt at systemidentitet-hash-funksjonen (System.identityHashCode(Object)) sprer elementene riktig blant bøttene. IdentityHashMap bruker ikke hashCode()-metoden i stedet for System.identityHashCode()-metoden. Dette er en betydelig forskjell fordi nå kan du bruke mutable objekter som nøkkel i Map hvis hash-kode sannsynligvis vil endres når kartleggingen er lagret i IdentityHashMap.

Erklæring:

offentlig klasse IdentityHashMap utvider AbstractMap implementerer Kart Serialiserbar Klonbar

Her K er nøkkelen Objekttype og V er verdien Objekttype.

I Java er IdentityHashMap en klasse som implementerer kartgrensesnittet. Den ligner på HashMap-klassen, med hovedforskjellen at IdentityHashMap bruker referanselikhet i stedet for objektlikhet når man sammenligner nøkler.

Mens HashMap bruker equals()-metoden for å sammenligne nøklene, bruker IdentityHashMap operatoren == for å sammenligne nøklene. Dette betyr at i en IdentityHashMap anses to nøkler som like hvis og bare hvis de er det samme objektet i stedet for å være like når det gjelder innholdet.

Her er et eksempel på hvordan du kan bruke et IdentityHashMap i 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      }   }

produksjon;

IdentityHashMap-klassen i Java er en hashtabellbasert implementering av Map-grensesnittet som bruker referanselikhet i stedet for objektlikhet ved sammenligning av nøkler (og verdier).

Fordeler med å bruke IdentityHashMap fremfor HashMap:

Raskere oppslag: Siden IdentityHashMap bruker referanselikhet for sammenligning, er det raskere for oppslag sammenlignet med HashMap som bruker objektlikhet.
Nyttig for å sammenligne objektforekomster: IdentityHashMap er nyttig i situasjoner der du ønsker å sammenligne objektforekomster i stedet for objektverdier.

Ulemper med å bruke IdentityHashMap:

Bruker mer minne: IdentityHashMap bruker mer minne sammenlignet med HashMap da den trenger å lagre referansen til objektet.
Ikke egnet for alle brukstilfeller: IdentityHashMap er ikke egnet for alle brukstilfeller og bør brukes med forsiktighet da det kan føre til uventet oppførsel i visse situasjoner.

Hierarki av IdentityHashMap

IdentityHashMap i Java

Den gjennomfører Serialiserbar Klonbar Kart grensesnitt og utvider Abstrakt kart klasse.

Eksempel:

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

Produksjon

Size of IdentityHashMap--2

Konstruktører av IdentityHashMap

Vi kan lage en forekomst av IdentityHashMap på to måter:

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

1. IdentityHashMap(): Konstruerer et nytt tomt identitets-hashkart med en standard forventet maksimal størrelse.

IdentityHashMap ham = nytt IdentityHashMap ();

2. IdentityHashMap(int forventetMaxSize): Konstruerer et nytt tomt kart med angitt forventet maksimal størrelse.

IdentityHashMap ihm = new IdentityHashMap(int forventetMaxSize);

3. IdentityHashMap(Kart m): Konstruerer et nytt hash-kart for identitet som inneholder nøkkelverdi-tilordningene i det angitte kartet.

IdentityHashMap ihm = new IdentityHashMap(Map m);

Grunnleggende operasjoner på IdentityHashMap

1. Legge til elementer

For å sette inn eller legge til kartlegging i et IdentityHashMap har vi sette() og putAll() metoder. put() kan sette inn en spesifikk nøkkel og verdien den tilordner til et bestemt kart. Hvis en eksisterende nøkkel sendes, blir den forrige verdien erstattet av den nye verdien. putAll() kopierer alle elementene, dvs. tilordningene fra ett kart til et annet.

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

Produksjon

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. Fjerning av elementer
For å fjerne kartlegginger bruker vi fjerne() en innebygd metode for IdentityHashMap-klassen og brukes til å fjerne tilordningen av en bestemt nøkkel fra kartet.

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

Produksjon

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. Få tilgang til elementene

Vi kan få tilgang til elementene i et IdentityHashMap ved å bruke bli() metode eksemplet på dette er gitt nedenfor.

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

Produksjon

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. Traversering
Vi kan bruke Iterator-grensesnittet til å krysse en hvilken som helst struktur i innsamlingsrammen. Siden iteratorer jobber med én type data, bruker vi Entry < ? ? >for å løse de to separate typene til et kompatibelt format. Ved å bruke neste()-metoden skriver vi ut elementene i 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  ());      }      }   }

Produksjon

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

Synchronized IdentityHashMap

Hvis flere tråder får tilgang til et identitets-hash-kart samtidig og minst én av trådene endrer kartet strukturelt, må det synkroniseres eksternt. (En strukturell modifikasjon er enhver operasjon som legger til eller sletter en eller flere tilordninger; bare å endre verdien knyttet til en nøkkel som en forekomst allerede inneholder, er ikke en strukturell modifikasjon.) Dette oppnås vanligvis ved å synkronisere på et objekt som naturlig innkapsler kartet. Hvis det ikke finnes noe slikt objekt, bør kartet "pakkes inn" ved hjelp av Collections.synchronizedMap metode. Dette gjøres best på opprettelsestidspunktet for å forhindre utilsiktet usynkronisert tilgang til kartet.

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

Metoder for IdentityHashMap

K – Typen av nøklene i kartet. V – Type verdier kartlagt i kartet.

METODE	BESKRIVELSE
klar()	Fjerner alle tilordningene fra dette kartet.
klone()	Returnerer en grunn kopi av dette identitets-hash-kartet: selve nøklene og verdiene er ikke klonet.
containsKey?(Objektnøkkel)	Tester om den angitte objektreferansen er en nøkkel i dette hash-kartet for identitet.
containsValue?(Objektverdi)	Tester om den angitte objektreferansen er en verdi i dette identitets-hash-kartet.
entrySet()	Returnerer en Sett visning av kartene i dette kartet.
lik?(Objekt o)	Sammenligner det angitte objektet med dette kartet for likhet.
få? (Objektnøkkel)	Returnerer verdien som den angitte nøkkelen er tilordnet til eller null hvis denne tilordningen ikke inneholder noen tilordning for nøkkelen.
hashkode()	Returnerer hash-kodeverdien for dette kartet.
isEmpty()	Returnerer sann hvis dette hash-kartet for identitet ikke inneholder noen nøkkelverdi-tilordninger.
keySet()	Returnerer en identitetsbasert settvisning av nøklene i dette kartet.
sette? (K nøkkel V verdi)	Knytter den angitte verdien til den spesifiserte nøkkelen i dette identitets-hash-kartet.
putAll? (Kart m)	Kopierer alle tilordningene fra det angitte kartet til dette kartet.
fjerne? (Objektnøkkel)	Fjerner tilordningen for denne nøkkelen fra dette kartet hvis det finnes.
størrelse()	Returnerer antall nøkkelverdi-tilordninger i dette hash-kartet for identitet.
verdier()	Returnerer en samlingsvisning av verdiene i dette kartet.

Metoder deklarert i klassen java.util.AbstractMap

METODE	BESKRIVELSE
toString()	Returnerer en strengrepresentasjon av dette kartet.

Metoder deklarert i grensesnittet java.util.Map

METODE	BESKRIVELSE
beregne? (K-tast BiFunction remappingFunction)	Forsøker å beregne en tilordning for den angitte nøkkelen og dens gjeldende tilordnede verdi (eller null hvis det ikke er noen gjeldende tilordning).
computeIfAbsent?(K-tast Funksjon mappingFunction)	Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), forsøker du å beregne verdien ved hjelp av den gitte tilordningsfunksjonen og legger den inn i dette kartet med mindre null.
computeIfPresent?(K-tast BiFunction remappingFunction)	Hvis verdien for den angitte nøkkelen er tilstede og ikke-null forsøker å beregne en ny tilordning gitt nøkkelen og dens gjeldende tilordnede verdi.
for hver? (BiConsumer handling)	Utfører den gitte handlingen for hver oppføring i dette kartet til alle oppføringer er behandlet eller handlingen gir et unntak.
getOrDefault?(Objektnøkkel V defaultValue)	Returnerer verdien som den angitte nøkkelen er tilordnet til eller standardverdi hvis dette kartet ikke inneholder noen tilordning for nøkkelen.
slå sammen?(K-tast V-verdi BiFunction remappingFunction)	Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi eller er assosiert med null, knytter den til den gitte ikke-nullverdien.
putIfAbsent? (K nøkkel V verdi)	Hvis den angitte nøkkelen ikke allerede er assosiert med en verdi (eller er tilordnet til null), knytter den til den gitte verdien og returnerer null ellers returnerer den gjeldende verdien.
fjerne? (Objektnøkkel Objektverdi)	Fjerner oppføringen for den angitte nøkkelen bare hvis den for øyeblikket er tilordnet den angitte verdien.
erstatte? (K nøkkel V verdi)	Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet til en verdi.
erstatte? (K-tast V oldValue V newValue)	Erstatter oppføringen for den angitte nøkkelen bare hvis den er tilordnet den angitte verdien.
replaceAll?(BiFunction funksjon)	Erstatter hver oppførings verdi med resultatet av å påkalle den gitte funksjonen på den oppføringen til alle oppføringer er behandlet eller funksjonen gir et unntak.

IdentityHashMap vs HashMap

IdentityHashMap bruker likhetsoperatoren '==' for å sammenligne nøkler og verdier mens HashMap bruker likhetsmetoden for å sammenligne nøkler og verdier inne i Map.
Siden IdentityHashMap ikke bruker equals(), er det relativt raskere enn HashMap for et objekt med dyre equals().
IdentityHashMap krever ikke at nøkler skal være uforanderlige siden det ikke er avhengig av equals().

Programmet nedenfor illustrerer forskjellen mellom IdentityHashMap og HashMap-implementering.

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

Produksjon

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

IdentityHashMap er en klasse i Java som implementerer kartgrensesnittet og bruker referanselikhet for å sammenligne nøkler. Det ligner på et vanlig HashMap, men det bruker ==-operatoren for å sammenligne nøkler i stedet for equals()-metoden. Dette betyr at to nøkler med samme innhold men forskjellige objektreferanser vil bli behandlet som distinkte nøkler i et IdentityHashMap.

Her er et eksempel på hvordan du bruker IdentityHashMap i 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      }   }

Produksjon

1 2 null

I dette eksemplet lager vi et IdentityHashMap som kartlegger strengnøkler til heltallsverdier. Vi legger til to nøkkelverdi-par til kartet ved å bruke to forskjellige strengobjekter som har samme innhold. Vi henter deretter verdier fra kartet ved å bruke samme og forskjellige String-objekter. Vi finner ut at vi kan hente verdier fra kartet ved å bruke de to forskjellige nøklene som har samme innhold, men vi kan ikke hente en verdi ved å bruke et String-objekt som har samme innhold, men som er en annen objektreferanse.

Merk at IdentityHashMap har en litt annen oppførsel enn et vanlig HashMap og er generelt bare nyttig i visse situasjoner der referanselikhet er viktig. I de fleste tilfeller er et vanlig HashMap tilstrekkelig og mer hensiktsmessig.

Lag quiz