The IdentityHashMap náradia Mapa pomocou rozhrania Hashtable použitie referenčnej rovnosti namiesto objektovej rovnosti pri porovnávaní kľúčov (a hodnôt). Táto trieda nie je univerzálna implementácia mapy. Hoci táto trieda implementuje rozhranie Map, zámerne porušuje všeobecnú zmluvu Map, ktorá nariaďuje použitie metódy equals() pri porovnávaní objektov. Táto trieda sa používa, keď používateľ požaduje porovnanie objektov prostredníctvom odkazu. Patrí k java.util balík.

Vlastnosti IdentityHashMap

• Nasleduje referenčnú rovnosť namiesto použitia metódy equals() používa operátor ==.
• Nie je synchronizovaný a musí byť synchronizovaný externe.
• Iterátory sú rýchle hádzanie ConcurrentModificationException pri pokuse o úpravu počas iterácie.
• Táto trieda poskytuje výkon v konštantnom čase pre základné operácie (získanie a vloženie) za predpokladu, že funkcia hash identity systému (System.identityHashCode(Object)) správne rozptýli prvky medzi segmenty. IdentityHashMap nepoužíva metódu hashCode(), namiesto toho používa metódu System.identityHashCode(). Toto je významný rozdiel, pretože teraz môžete použiť meniteľné objekty ako kľúč v Mape, ktorých hash kód sa pravdepodobne zmení, keď je mapovanie uložené v IdentityHashMap.

Vyhlásenie:

verejná trieda IdentityHashMaprozširuje AbstractMapimplementuje MapSerializovateľné Klonovateľné 
 

Tu K je kľúčový Typ objektu a V je hodnota Typ objektu.

V jazyku Java je IdentityHashMap trieda, ktorá implementuje rozhranie Map. Je podobná triede HashMap s hlavným rozdielom, že IdentityHashMap používa referenčnú rovnosť namiesto objektovej rovnosti pri porovnávaní kľúčov.

Zatiaľ čo HashMap používa metódu equals() na porovnanie kľúčov, IdentityHashMap používa na porovnanie kľúčov operátor ==. To znamená, že v IdentityHashMap sa dva kľúče považujú za rovnocenné vtedy a len vtedy, ak sú rovnakým objektom, a nie sú rovnaké z hľadiska ich obsahu.

vikas divyakirti

Tu je príklad toho, ako môžete použiť IdentityHashMap v jazyku 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  } } 

výstup;

2 

1

Trieda IdentityHashMap v jazyku Java je implementácia rozhrania Map založená na hašovacej tabuľke, ktorá pri porovnávaní kľúčov (a hodnôt) používa referenčnú rovnosť namiesto objektovej rovnosti.

Výhody použitia IdentityHashMap oproti HashMap:

1. Rýchlejšie vyhľadávanie: Keďže IdentityHashMap používa referenčnú rovnosť na porovnanie, je rýchlejšia pri vyhľadávaní v porovnaní s HashMap, ktorá používa objektovú rovnosť.
2. Užitočné na porovnávanie inštancií objektov: IdentityHashMap je užitočná v situáciách, keď chcete porovnávať inštancie objektu a nie hodnoty objektu.

Nevýhody používania IdentityHashMap:

1. Používa viac pamäte: IdentityHashMap využíva viac pamäte v porovnaní s HashMap, pretože potrebuje uložiť odkaz na objekt.
2. Nie je vhodný pre všetky prípady použitia: IdentityHashMap nie je vhodný pre všetky prípady použitia a mal by sa používať opatrne, pretože v určitých situáciách môže viesť k neočakávanému správaniu.

Hierarchia IdentityHashMap

Realizuje Serializovateľné Klonovateľné Mapa rozhrania a rozširuje Abstraktná mapa trieda.

Príklad:

normálne formy

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

Konštruktéri IdentityHashMap

Môžeme vytvoriť inštanciu IdentityHashMap dvoma spôsobmi:

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

1. IdentityHashMap():  Vytvorí novú prázdnu mapu hash identity s predvolenou očakávanou maximálnou veľkosťou. 

IdentityHashMapho = nová IdentityHashMap();

2. IdentityHashMap (int expectMaxSize):  Vytvorí novú prázdnu mapu so zadanou očakávanou maximálnou veľkosťou. 

IdentityHashMapihm = new IdentityHashMap (int očakávanáMaxSize);

3. IdentityHashMap(Mapa m):  Vytvorí novú mapu hash identity obsahujúcu mapovania párov kľúč – hodnota v zadanej mape.

IdentityHashMapihm = new IdentityHashMap(Map m);

Základné operácie na IdentityHashMap

1. Pridávanie prvkov

Na vloženie alebo pridanie mapovania do IdentityHashMap máme dať () a putAll() metódy. put() môže vložiť špecifický kľúč a hodnotu, ktorú mapuje, do konkrétnej mapy. Ak je odovzdaný existujúci kľúč, predchádzajúca hodnota sa nahradí novou hodnotou. putAll() skopíruje všetky prvky, t.j. mapovania z jednej mapy do druhej. 

// 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. Odstránenie prvkov
Na odstránenie mapovaní, ktoré používame odstrániť () vstavaná metóda triedy IdentityHashMap a používa sa na odstránenie mapovania akéhokoľvek konkrétneho kľúča z mapy.

// 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. Prístup k prvkom

K prvkom IdentityHashMap môžeme pristupovať pomocou dostať () spôsob, tento príklad je uvedený nižšie.

// 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. Prechádzanie
Rozhranie Iterator môžeme použiť na prechádzanie cez akúkoľvek štruktúru Collection Framework. Keďže iterátory pracujú s jedným typom údajov, používame Entry< ? ? >na rozlíšenie dvoch samostatných typov do kompatibilného formátu. Potom pomocou metódy next() vytlačíme prvky IdentityHashMap.

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

Synchronizovaná IdentityHashMap

Ak k mape hash identity pristupuje viacero vlákien súčasne a aspoň jedno z vlákien štrukturálne modifikuje mapu, musí byť synchronizovaná externe. (Štrukturálna modifikácia je akákoľvek operácia, ktorá pridáva alebo odstraňuje jedno alebo viac mapovaní; len zmena hodnoty spojenej s kľúčom, ktorý inštancia už obsahuje, nie je štrukturálnou modifikáciou.) Zvyčajne sa to dosiahne synchronizáciou na nejakom objekte, ktorý prirodzene zapuzdruje mapu. Ak takýto objekt neexistuje, mapa by mala byť „zabalená“ pomocou Collections.synchronizedMap metóda. Najlepšie je to urobiť v čase vytvorenia, aby ste predišli náhodnému nesynchronizovanému prístupu k mape. 

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

Metódy IdentityHashMap

K– Typ kľúčov na mape.V– Typ hodnôt mapovaných na mape.

Metódy deklarované v triede java.util.AbstractMap

Metódy deklarované v rozhraní java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap používa operátor rovnosti '==' na porovnávanie kľúčov a hodnôt, zatiaľ čo HashMap používa metódu rovná sa na porovnávanie kľúčov a hodnôt v rámci mapy.
• Keďže IdentityHashMap nepoužíva equals(), je porovnateľne rýchlejší ako HashMap pre objekt s drahým equals().
• IdentityHashMap nevyžaduje, aby boli kľúče nemenné, pretože sa nespolieha na equals().

Nižšie uvedený program ilustruje rozdiel medzi implementáciou IdentityHashMap a 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 je trieda v jazyku Java, ktorá implementuje rozhranie mapy a používa referenčnú rovnosť na porovnávanie kľúčov. Je podobná bežnej HashMap, ale na porovnanie kľúčov používa operátor == namiesto metódy equals(). To znamená, že dva kľúče s rovnakým obsahom, ale rôznymi referenciami na objekt, sa budú v IdentityHashMap považovať za odlišné kľúče.

Tu je príklad, ako používať IdentityHashMap v jazyku 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 

V tomto príklade vytvoríme IdentityHashMap, ktorá mapuje kľúče String na celočíselné hodnoty. Do mapy pridávame dva páry kľúč – hodnota pomocou dvoch rôznych objektov typu String, ktoré majú rovnaký obsah. Potom získame hodnoty z mapy pomocou rovnakých a rôznych objektov String. Zistili sme, že môžeme získať hodnoty z mapy pomocou dvoch rôznych kľúčov, ktoré majú rovnaký obsah, ale nemôžeme získať hodnotu pomocou objektu String, ktorý má rovnaký obsah, ale je iným odkazom na objekt.

Všimnite si, že IdentityHashMap má mierne odlišné správanie ako bežná HashMap a je vo všeobecnosti užitočná len v určitých situáciách, kde je dôležitá rovnosť odkazov. Vo väčšine prípadov je postačujúca a vhodnejšia bežná HashMap.

java for loop