IDENTITYHASHMAP-KLASSE IN JAVA

De IdentiteitHashMap werktuigen Kaart interface gebruiken Hashtabel het gebruik van referentie-gelijkheid in plaats van object-gelijkheid bij het vergelijken van sleutels (en waarden). Deze klasse is geen kaartimplementatie voor algemene doeleinden. Hoewel deze klasse de Map-interface implementeert, schendt deze opzettelijk het algemene contract van Map, dat het gebruik van de equals()-methode verplicht bij het vergelijken van objecten. Deze klasse wordt gebruikt wanneer de gebruiker vereist dat de objecten via referentie worden vergeleken. Het behoort tot java.util pakket.

Kenmerken van IdentityHashMap

Het volgt referentie-gelijkheid in plaats van de equals()-methode te gebruiken, maar gebruikt de == operator.
Het is niet gesynchroniseerd en moet extern worden gesynchroniseerd.
Iterators zijn fail-fast-throw ConcurrentModificationException in een poging om tijdens het itereren te wijzigen.
Deze klasse biedt constante prestaties voor de basisbewerkingen (get en put), ervan uitgaande dat de hashfunctie van de systeemidentiteit (System.identityHashCode(Object)) de elementen op de juiste manier over de buckets verspreidt. IdentityHashMap maakt geen gebruik van de hashCode()-methode, maar gebruikt de System.identityHashCode()-methode. Dit is een aanzienlijk verschil, omdat u nu veranderlijke objecten als sleutel in Map kunt gebruiken, waarvan de hashcode waarschijnlijk zal veranderen wanneer de mapping wordt opgeslagen in IdentityHashMap.

Verklaring:

openbare klasse IdentityHashMap breidt AbstractMap uit implementeert Kaart Serialiseerbaar, kloonbaar

Hier K is het belangrijkste objecttype en V is de waarde Objecttype.

In Java is IdentityHashMap een klasse die de Map-interface implementeert. Het is vergelijkbaar met de klasse HashMap, met als belangrijkste verschil dat IdentityHashMap referentiegelijkheid gebruikt in plaats van objectgelijkheid bij het vergelijken van sleutels.

Terwijl HashMap de methode equals() gebruikt om de sleutels te vergelijken, gebruikt IdentityHashMap de operator == om de sleutels te vergelijken. Dit betekent dat in een IdentityHashMap twee sleutels als gelijk worden beschouwd als en slechts als ze hetzelfde object zijn, en niet als ze qua inhoud gelijk zijn.

Hier is een voorbeeld van hoe u een IdentityHashMap in Java zou kunnen gebruiken:

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

uitvoer;

De klasse IdentityHashMap in Java is een op hashtabellen gebaseerde implementatie van de Map-interface die referentie-gelijkheid gebruikt in plaats van object-gelijkheid bij het vergelijken van sleutels (en waarden).

Voordelen van het gebruik van IdentityHashMap ten opzichte van HashMap:

Snellere zoekopdrachten: Omdat IdentityHashMap ter vergelijking referentie-gelijkheid gebruikt, zijn zoekopdrachten sneller dan HashMap, die object-gelijkheid gebruikt.
Handig voor het vergelijken van objectinstanties: IdentityHashMap is handig in situaties waarin u objectinstanties wilt vergelijken in plaats van objectwaarden.

Nadelen van het gebruik van IdentityHashMap:

Gebruikt meer geheugen: IdentityHashMap gebruikt meer geheugen vergeleken met HashMap omdat het de verwijzing naar het object moet opslaan.
Niet geschikt voor alle gebruiksscenario's: IdentityHashMap is niet geschikt voor alle gebruiksscenario's en moet met voorzichtigheid worden gebruikt, omdat dit in bepaalde situaties tot onverwacht gedrag kan leiden.

De hiërarchie van IdentityHashMap

IdentityHashMap in Java

Het implementeert Serialiseerbaar Kloonbaar Kaart raakvlakken en breidt uit Samenvattingkaart klas.

Voorbeeld:

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

Uitvoer

Size of IdentityHashMap--2

Constructeurs van IdentityHashMap

We kunnen een exemplaar maken van IdentiteitHashMap op twee manieren:

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

1. IdentiteitHashMap(): Construeert een nieuwe lege identiteitshashkaart met een standaard verwachte maximale grootte.

IdentiteitHashMap hem = nieuwe IdentityHashMap ();

2. IdentityHashMap (int verwachteMaxSize): Construeert een nieuwe lege kaart met de opgegeven verwachte maximale grootte.

IdentiteitHashMap ihm = nieuwe IdentityHashMap (int verwachteMaxSize);

3. IdentityHashMap(Kaart m): Construeert een nieuwe identiteitshashkaart met de sleutelwaardetoewijzingen in de opgegeven kaart.

IdentiteitHashMap ihm = nieuwe IdentityHashMap(Kaart m);

Basisbewerkingen op IdentityHashMap

1. Elementen toevoegen

Om mapping in te voegen of toe te voegen aan een IdentityHashMap hebben we neerzetten() En zetAlles() methoden. put() kan een specifieke sleutel en de waarde die deze in kaart brengt in een bepaalde kaart invoegen. Als een bestaande sleutel wordt doorgegeven, wordt de vorige waarde vervangen door de nieuwe waarde. putAll() kopieert alle elementen, dat wil zeggen de toewijzingen van de ene kaart naar de andere.

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

Uitvoer

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. Elementen verwijderen
Om mappings te verwijderen gebruiken we verwijderen() een ingebouwde methode van de IdentityHashMap-klasse en wordt gebruikt om de toewijzing van een bepaalde sleutel van de kaart te verwijderen.

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

Uitvoer

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. Toegang tot de elementen

We hebben toegang tot de elementen van een IdentityHashMap met behulp van de krijgen() methode Het voorbeeld hiervan wordt hieronder gegeven.

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

Uitvoer

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. Doorkruisen
We kunnen de Iterator-interface gebruiken om elke structuur van het Collection Framework te doorlopen. Omdat Iterators met één type data werken, gebruiken we Entry < ? ? >om de twee afzonderlijke typen om te zetten in een compatibel formaat. Vervolgens drukken we met behulp van de next()-methode de elementen van de IdentityHashMap af.

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

Uitvoer

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

Gesynchroniseerde IdentityHashMap

Als meerdere threads tegelijkertijd toegang hebben tot een identiteitshashkaart en ten minste één van de threads de kaart structureel wijzigt, moet deze extern worden gesynchroniseerd. (Een structurele wijziging is elke bewerking die een of meer toewijzingen toevoegt of verwijdert; alleen het wijzigen van de waarde die is gekoppeld aan een sleutel die een instantie al bevat, is geen structurele wijziging.) Dit wordt doorgaans bereikt door te synchroniseren op een object dat de kaart op natuurlijke wijze inkapselt. Als een dergelijk object niet bestaat, moet de kaart worden 'ingepakt' met behulp van de Collections.gesynchroniseerde kaart methode. Dit kunt u het beste doen tijdens het maken van de kaart, om onbedoelde, niet-gesynchroniseerde toegang tot de kaart te voorkomen.

Kaart m = Collections.synchronizedMap(nieuwe IdentityHashMap(...));

Methoden van IdentityHashMap

K – Het type sleutels op de kaart. V – Het type waarden dat op de kaart in kaart is gebracht.

METHODE	BESCHRIJVING
duidelijk()	Verwijdert alle toewijzingen van deze kaart.
kloon()	Retourneert een oppervlakkige kopie van deze identiteitshashkaart: de sleutels en waarden zelf worden niet gekloond.
bevatsleutel? (Objectsleutel)	Test of de opgegeven objectreferentie een sleutel is in deze identiteitshashkaart.
bevatWaarde?(Objectwaarde)	Test of de opgegeven objectreferentie een waarde is in deze identiteitshashkaart.
entrySet()	Retourneert een Set weergave van de kaarten op deze kaart.
gelijk aan? (Object o)	Vergelijkt het opgegeven object met deze kaart op gelijkheid.
krijgen?(Objectsleutel)	Retourneert de waarde waaraan de opgegeven sleutel is toegewezen, of null als deze toewijzing geen toewijzing voor de sleutel bevat.
hashCode()	Retourneert de hashcodewaarde voor deze kaart.
isLeeg()	Retourneert waar als deze identiteit-hash-kaart geen sleutel-waarde-toewijzingen bevat.
sleutelSet()	Retourneert een op identiteit gebaseerde setweergave van de sleutels in deze kaart.
put?(K-sleutel V-waarde)	Koppelt de opgegeven waarde aan de opgegeven sleutel in deze identiteitshashkaart.
alles zetten? (kaart M)	Kopieert alle toewijzingen van de opgegeven kaart naar deze kaart.
verwijderen?(Objectsleutel)	Verwijdert de toewijzing voor deze sleutel uit deze kaart, indien aanwezig.
maat()	Retourneert het aantal sleutel/waarde-toewijzingen in deze identiteit-hash-kaart.
waarden()	Retourneert een verzamelingsweergave van de waarden in deze kaart.

Methoden gedeclareerd in klasse java.util.AbstractMap

METHODE	BESCHRIJVING
toString()	Retourneert een tekenreeksweergave van deze kaart.

Methoden gedeclareerd in interface java.util.Map

METHODE	BESCHRIJVING
berekenen?(K-toets BiFunction opnieuw toewijzenFunctie)	Probeert een toewijzing te berekenen voor de opgegeven sleutel en de huidige toegewezen waarde (of null als er geen huidige toewijzing is).
computeIfAbsent?(K-toetsfunctie mappingFunctie)	Als de opgegeven sleutel nog niet aan een waarde is gekoppeld (of is toegewezen aan null), wordt geprobeerd de waarde ervan te berekenen met behulp van de gegeven toewijzingsfunctie en deze in deze kaart in te voeren, tenzij null.
computeIfPresent?(K-toets BiFunction opnieuw toewijzenFunctie)	Als de waarde voor de opgegeven sleutel aanwezig is en niet nul is, wordt geprobeerd een nieuwe toewijzing te berekenen op basis van de sleutel en de huidige toegewezen waarde.
voorElk?(BiConsumer actie)	Voert de gegeven actie uit voor elk item op deze kaart totdat alle items zijn verwerkt of de actie een uitzondering genereert.
getOrDefault?(Objectsleutel V standaardwaarde)	Retourneert de waarde waaraan de opgegeven sleutel is toegewezen, of defaultValue als deze toewijzing geen toewijzing voor de sleutel bevat.
samenvoegen?(K-toets V-waarde BiFunction opnieuw toewijzenFunctie)	Als de opgegeven sleutel nog niet aan een waarde is gekoppeld of aan null is gekoppeld, wordt deze aan de opgegeven niet-null-waarde gekoppeld.
putIfAbsent?(K sleutel V-waarde)	Als de opgegeven sleutel nog niet aan een waarde is gekoppeld (of is toegewezen aan null), wordt deze aan de opgegeven waarde gekoppeld en wordt null geretourneerd, anders wordt de huidige waarde geretourneerd.
verwijderen?(Objectsleutel Objectwaarde)	Verwijdert de vermelding voor de opgegeven sleutel alleen als deze momenteel is toegewezen aan de opgegeven waarde.
vervangen?(K sleutel V-waarde)	Vervangt de vermelding voor de opgegeven sleutel alleen als deze momenteel aan een bepaalde waarde is toegewezen.
vervangen?(K sleutel V oudeWaarde V nieuweWaarde)	Vervangt de vermelding voor de opgegeven sleutel alleen als deze momenteel is toegewezen aan de opgegeven waarde.
alles vervangen? (BiFunction functie)	Vervangt de waarde van elk item door het resultaat van het aanroepen van de gegeven functie voor dat item totdat alle items zijn verwerkt of de functie een uitzondering genereert.

IdentityHashMap vs HashMap

IdentityHashMap gebruikt de gelijkheidsoperator '==' voor het vergelijken van sleutels en waarden, terwijl HashMap de equals-methode gebruikt voor het vergelijken van sleutels en waarden binnen Map.
Omdat IdentityHashMap equals() niet gebruikt, is het relatief sneller dan HashMap voor een object met dure equals().
IdentityHashMap vereist niet dat sleutels onveranderlijk zijn, omdat er niet op equals() wordt vertrouwd.

Het onderstaande programma illustreert het verschil tussen de implementatie van IdentityHashMap en 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  ());          }   }

Uitvoer

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

IdentityHashMap is een klasse in Java die de Map-interface implementeert en referentiegelijkheid gebruikt om sleutels te vergelijken. Het is vergelijkbaar met een gewone HashMap, maar gebruikt de == operator om sleutels te vergelijken in plaats van de equals() methode. Dit betekent dat twee sleutels met dezelfde inhoud maar verschillende objectreferenties als afzonderlijke sleutels in een IdentityHashMap worden behandeld.

Hier is een voorbeeld van het gebruik van IdentityHashMap in 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      }   }

Uitvoer

1 2 null

In dit voorbeeld maken we een IdentityHashMap die String-sleutels toewijst aan Integer-waarden. We voegen twee sleutelwaardeparen toe aan de kaart met behulp van twee verschillende String-objecten die dezelfde inhoud hebben. Vervolgens halen we waarden uit de kaart op met behulp van dezelfde en verschillende String-objecten. We ontdekken dat we waarden uit de kaart kunnen ophalen met behulp van de twee verschillende sleutels die dezelfde inhoud hebben, maar we kunnen geen waarde ophalen met behulp van een String-object dat dezelfde inhoud heeft maar een andere objectreferentie is.

Houd er rekening mee dat IdentityHashMap zich enigszins anders gedraagt dan een gewone HashMap en over het algemeen alleen nuttig is in bepaalde situaties waarin referentiegelijkheid belangrijk is. In de meeste gevallen is een gewone HashMap voldoende en geschikter.

Quiz maken