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 IdentityHashMapbreidt AbstractMap uitimplementeert KaartSerialiseerbaar, 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.

sites zoals coomeet

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

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;

2 

1

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:

1. Snellere zoekopdrachten: Omdat IdentityHashMap ter vergelijking referentie-gelijkheid gebruikt, zijn zoekopdrachten sneller dan HashMap, die object-gelijkheid gebruikt.
2. 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:

1. Gebruikt meer geheugen: IdentityHashMap gebruikt meer geheugen vergeleken met HashMap omdat het de verwijzing naar het object moet opslaan.
2. 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

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

Voorbeeld:

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

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. 

IdentiteitHashMaphem = nieuwe IdentityHashMap();

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

IdentiteitHashMapihm = nieuwe IdentityHashMap (int verwachteMaxSize);

palindroom in Java

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

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

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

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

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

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

verschil tussen tijger en leeuw

Methoden van IdentityHashMap

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

Methoden gedeclareerd in klasse java.util.AbstractMap

Methoden gedeclareerd in interface java.util.Map

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

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:

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

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.

bevat subtekenreeks Java