Der IdentityHashMap implementiert Karte Schnittstelle verwenden Hashtabelle Verwenden von Referenzgleichheit anstelle von Objektgleichheit beim Vergleich von Schlüsseln (und Werten). Diese Klasse ist keine Allzweck-Map-Implementierung. Während diese Klasse die Map-Schnittstelle implementiert, verstößt sie absichtlich gegen den allgemeinen Vertrag von Map, der die Verwendung der Methode equal() beim Vergleichen von Objekten vorschreibt. Diese Klasse wird verwendet, wenn der Benutzer einen Vergleich der Objekte per Referenz anfordert. Es gehört dazu java.util Paket.

Funktionen von IdentityHashMap

• Es folgt der Referenzgleichheit, anstatt die Methode equal() zu verwenden, verwendet es den Operator ==.
• Es ist nicht synchronisiert und muss extern synchronisiert werden.
• Iteratoren sind ausfallsicher ConcurrentModificationException in einem Versuch, während der Iteration Änderungen vorzunehmen.
• Diese Klasse bietet eine konstante Leistung für die Grundoperationen (Get und Put), vorausgesetzt, dass die Systemidentitäts-Hash-Funktion (System.identityHashCode(Object)) die Elemente ordnungsgemäß auf die Buckets verteilt. IdentityHashMap verwendet nicht die Methode hashCode(), sondern die Methode System.identityHashCode(). Dies ist ein wesentlicher Unterschied, da Sie jetzt veränderliche Objekte als Schlüssel in Map verwenden können, deren Hash-Code sich wahrscheinlich ändert, wenn die Zuordnung in IdentityHashMap gespeichert wird.

Erklärung:

öffentliche Klasse IdentityHashMaperweitert AbstractMapimplementiert MapSerialisierbar, klonbar 
 

Hier K ist der Schlüsselobjekttyp und V ist der Wert Objekttyp.

In Java ist IdentityHashMap eine Klasse, die die Map-Schnittstelle implementiert. Sie ähnelt der HashMap-Klasse, mit dem Hauptunterschied, dass IdentityHashMap beim Vergleich von Schlüsseln Referenzgleichheit anstelle von Objektgleichheit verwendet.

Während HashMap die Methode equal() verwendet, um die Schlüssel zu vergleichen, verwendet IdentityHashMap den Operator ==, um die Schlüssel zu vergleichen. Das bedeutet, dass in einer IdentityHashMap zwei Schlüssel genau dann als gleich gelten, wenn sie dasselbe Objekt sind und nicht inhaltlich gleich sind.

Shilpa Shetty

Hier ist ein Beispiel dafür, wie Sie eine IdentityHashMap in Java verwenden könnten:

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

Ausgabe;

2 

1

Die IdentityHashMap-Klasse in Java ist eine Hash-Tabellen-basierte Implementierung der Map-Schnittstelle, die beim Vergleich von Schlüsseln (und Werten) Referenzgleichheit anstelle von Objektgleichheit verwendet.

Vorteile der Verwendung von IdentityHashMap gegenüber HashMap:

1. Schnellere Suchvorgänge: Da IdentityHashMap zum Vergleich Referenzgleichheit verwendet, sind Suchvorgänge im Vergleich zu HashMap, das Objektgleichheit verwendet, schneller.
2. Nützlich zum Vergleichen von Objektinstanzen: IdentityHashMap ist in Situationen nützlich, in denen Sie Objektinstanzen und nicht Objektwerte vergleichen möchten.

Nachteile der Verwendung von IdentityHashMap:

1. Benötigt mehr Speicher: IdentityHashMap benötigt im Vergleich zu HashMap mehr Speicher, da es den Verweis auf das Objekt speichern muss.
2. Nicht für alle Anwendungsfälle geeignet: IdentityHashMap ist nicht für alle Anwendungsfälle geeignet und sollte mit Vorsicht verwendet werden, da es in bestimmten Situationen zu unerwartetem Verhalten führen kann.

Die Hierarchie von IdentityHashMap

Es setzt um Serialisierbar Klonbar Karte Schnittstellen und Erweiterungen AbstractMap Klasse.

Beispiel:

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

Size of IdentityHashMap--2 

Konstruktoren von IdentityHashMap

Wir können eine Instanz von erstellen IdentityHashMap auf zwei Arten:

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

1. IdentityHashMap():  Erstellt eine neue leere Identitäts-Hash-Map mit einer standardmäßig erwarteten maximalen Größe. 

IdentityHashMapihm = new IdentityHashMap();

2. IdentityHashMap(int erwartetMaxSize):  Erstellt eine neue leere Karte mit der angegebenen erwarteten maximalen Größe. 

IdentityHashMapihm = new IdentityHashMap(int erwartetMaxSize);

3. IdentityHashMap(Map m):  Erstellt eine neue Identitäts-Hash-Map, die die Schlüssel-Wert-Zuordnungen in der angegebenen Karte enthält.

IdentityHashMapihm = new IdentityHashMap(Map m);

Grundlegende Operationen auf IdentityHashMap

1. Elemente hinzufügen

Um eine Zuordnung in eine IdentityHashMap einzufügen oder hinzuzufügen, haben wir setzen() Und putAll() Methoden. put() kann einen bestimmten Schlüssel und den Wert, den er zuordnet, in eine bestimmte Karte einfügen. Wenn ein vorhandener Schlüssel übergeben wird, wird der vorherige Wert durch den neuen Wert ersetzt. putAll() kopiert alle Elemente, also die Zuordnungen, von einer Karte in eine 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. Elemente entfernen
Zum Entfernen von Zuordnungen verwenden wir entfernen() ist eine integrierte Methode der IdentityHashMap-Klasse und wird verwendet, um die Zuordnung eines bestimmten Schlüssels aus der Zuordnung zu entfernen.

// 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. Zugriff auf die Elemente

Wir können über die auf die Elemente einer IdentityHashMap zugreifen erhalten() Methode Das Beispiel hierfür ist unten angegeben.

// 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. Überqueren
Wir können die Iterator-Schnittstelle verwenden, um jede Struktur des Collection Framework zu durchlaufen. Da Iteratoren mit einem Datentyp arbeiten, verwenden wir Entry< ? ? >um die beiden getrennten Typen in ein kompatibles Format aufzulösen. Anschließend drucken wir mit der Methode next() die Elemente der IdentityHashMap aus.

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

Synchronisierte IdentityHashMap

Wenn mehrere Threads gleichzeitig auf eine Identitäts-Hash-Map zugreifen und mindestens einer der Threads die Map strukturell ändert, muss sie extern synchronisiert werden. (Eine strukturelle Änderung ist jeder Vorgang, der eine oder mehrere Zuordnungen hinzufügt oder löscht; die bloße Änderung des Werts, der einem Schlüssel zugeordnet ist, den eine Instanz bereits enthält, stellt keine strukturelle Änderung dar.) Dies wird normalerweise durch Synchronisierung auf einem Objekt erreicht, das die Zuordnung auf natürliche Weise kapselt. Wenn kein solches Objekt vorhanden ist, sollte die Karte mit dem „umbrochen“ werden Collections.synchronizedMap Verfahren. Dies geschieht am besten zum Zeitpunkt der Erstellung, um einen versehentlichen, nicht synchronisierten Zugriff auf die Karte zu verhindern. 

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

Methoden von IdentityHashMap

K– Der Typ der Schlüssel in der Karte.V– Die Art der in der Karte abgebildeten Werte.

In der Klasse java.util.AbstractMap deklarierte Methoden

In der Schnittstelle java.util.Map deklarierte Methoden

IdentityHashMap vs  HashMap

• IdentityHashMap verwendet den Gleichheitsoperator „==“ zum Vergleichen von Schlüsseln und Werten, während HashMap die Methode „equals“ zum Vergleichen von Schlüsseln und Werten innerhalb von Map verwendet.
• Da IdentityHashMap nicht equal() verwendet, ist es vergleichsweise schneller als HashMap für ein Objekt mit teurem equal().
• Für IdentityHashMap ist es nicht erforderlich, dass Schlüssel unveränderlich sind, da es nicht auf equal() basiert.

Das folgende Programm veranschaulicht den Unterschied zwischen der IdentityHashMap- und der HashMap-Implementierung.

// 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 ist eine Klasse in Java, die die Map-Schnittstelle implementiert und Referenzgleichheit zum Vergleichen von Schlüsseln verwendet. Es ähnelt einer regulären HashMap, verwendet jedoch den Operator == zum Vergleichen von Schlüsseln anstelle der Methode equal(). Das bedeutet, dass zwei Schlüssel mit demselben Inhalt, aber unterschiedlichen Objektreferenzen in einer IdentityHashMap als unterschiedliche Schlüssel behandelt werden.

Hier ist ein Beispiel für die Verwendung von 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 diesem Beispiel erstellen wir eine IdentityHashMap, die String-Schlüssel Integer-Werten zuordnet. Wir fügen der Karte zwei Schlüssel-Wert-Paare hinzu, indem wir zwei verschiedene String-Objekte mit demselben Inhalt verwenden. Anschließend rufen wir Werte aus der Karte ab, indem wir dieselben und verschiedene String-Objekte verwenden. Wir stellen fest, dass wir Werte aus der Karte abrufen können, indem wir zwei verschiedene Schlüssel verwenden, die denselben Inhalt haben. Wir können jedoch keinen Wert mithilfe eines String-Objekts abrufen, das denselben Inhalt hat, aber eine andere Objektreferenz darstellt.

Beachten Sie, dass sich IdentityHashMap etwas anders verhält als eine normale HashMap und im Allgemeinen nur in bestimmten Situationen nützlich ist, in denen Referenzgleichheit wichtig ist. In den meisten Fällen ist eine reguläre HashMap ausreichend und geeigneter.

Prioritätswarteschlange