A IdentityHashMap megvalósítja Térkép interfész segítségével Hashtable referencia-egyenlőség használata az objektum-egyenlőség helyett a kulcsok (és értékek) összehasonlításakor. Ez az osztály nem egy általános célú térkép-megvalósítás. Bár ez az osztály megvalósítja a Map interfészt, szándékosan megsérti a Map általános szerződését, amely előírja az equals() metódus használatát az objektumok összehasonlításakor. Ezt az osztályt akkor használjuk, ha a felhasználó megköveteli az objektumok referencia útján történő összehasonlítását. hozzátartozik java.util csomag.

Az IdentityHashMap jellemzői

• A referenciaegyenlőséget követi az equals() metódus helyett, az == operátort használja.
• Nincs szinkronizálva, és külsőleg kell szinkronizálni.
• Az iterátorok hibagyors dobások ConcurrentModificationException iteráció közben próbálva módosítani.
• Ez az osztály állandó idejű teljesítményt biztosít az alapvető műveletekhez (get és put), feltételezve, hogy a rendszeridentitás-kivonatoló függvény (System.identityHashCode(Object)) megfelelően szétosztja az elemeket a tárolók között. Az IdentityHashMap nem használja a hashCode() metódust, hanem a System.identityHashCode() metódust. Ez jelentős különbség, mert mostantól a Map kulcsaként használhat olyan módosítható objektumokat, amelyek hash kódja valószínűleg megváltozik, amikor a leképezést az IdentityHashMapben tárolják.

Nyilatkozat:

nyilvános osztály IdentityHashMapkiterjeszti az AbstractMap-ettérképet valósít megSorosozható klónozható 
 

Itt K a kulcs Objektumtípus és V az objektum típusa.

A Java-ban az IdentityHashMap egy osztály, amely megvalósítja a Map felületet. Hasonló a HashMap osztályhoz, azzal a fő különbséggel, hogy az IdentityHashMap referenciaegyenlőséget használ az objektum egyenlőség helyett a kulcsok összehasonlításakor.

Míg a HashMap az equals() metódust használja a kulcsok összehasonlítására, az IdentityHashMap az == operátort használja a kulcsok összehasonlításához. Ez azt jelenti, hogy az IdentityHashMap-ben két kulcs akkor és csak akkor tekintendő egyenlőnek, ha ugyanaz az objektum, nem pedig tartalmukat tekintve egyenlőek.

urfi javed

Íme egy példa arra, hogyan használhatja az IdentityHashMap-et Java-ban:

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

kimenet;

2 

1

A Java IdentityHashMap osztálya a Map interfész hash tábla alapú megvalósítása, amely a referencia-egyenlőséget használja az objektum-egyenlőség helyett a kulcsok (és értékek) összehasonlításakor.

Az IdentityHashMap használatának előnyei a HashMap-pel szemben:

1. Gyorsabb keresések: Mivel az IdentityHashMap referencia-egyenlőséget használ az összehasonlításhoz, gyorsabb a kereséseknél, mint az objektum-egyenlőséget használó HashMap.
2. Hasznos objektumpéldányok összehasonlításához: Az IdentityHashMap olyan helyzetekben hasznos, amikor objektumpéldányokat szeretne összehasonlítani az objektumértékek helyett.

Az IdentityHashMap használatának hátrányai:

1. Több memóriát használ: Az IdentityHashMap több memóriát használ a HashMaphez képest, mivel tárolnia kell az objektumra mutató hivatkozást.
2. Nem alkalmas minden felhasználási esetre: Az IdentityHashMap nem alkalmas minden felhasználási esetre, és óvatosan kell használni, mert bizonyos helyzetekben váratlan viselkedéshez vezethet.

Az IdentityHashMap hierarchiája

Megvalósítja Sorozatozható Klónozható Térkép interfészeket és kiterjeszti AbstractMap osztály.

Példa:

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

Az IdentityHashMap konstruktőrei

Létrehozhatunk egy példányt IdentityHashMap kétféleképpen:

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

1. IdentityHashMap():  Új üres identitáskivonat-leképezést hoz létre az alapértelmezett várható maximális mérettel. 

IdentityHashMapőt = új IdentityHashMap();

2. IdentityHashMap(int vártMaxSize):  Új üres térképet hoz létre a megadott várható maximális mérettel. 

IdentityHashMapihm = new IdentityHashMap(int vártMaxSize);

3. IdentityHashMap(m térkép):  Létrehoz egy új identitáskivonat-leképezést, amely tartalmazza a kulcsérték-leképezéseket a megadott leképezésben.

IdentityHashMapihm = new IdentityHashMap(M térkép);

homogén keverék

Az IdentityHashMap alapvető műveletei

1. Elemek hozzáadása

Leképezés beszúrásához vagy hozzáadásához egy IdentityHashMap-hez tesz() és mindent elhelyez() mód. A put() beszúrhat egy adott kulcsot és az általa leképezett értéket egy adott térképbe. Ha egy meglévő kulcsot adunk át, akkor az előző érték helyébe az új érték lép. A putAll() az összes elemet, azaz a leképezéseket az egyik térképről a másikra másolja. 

java vizualizáló

// 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. Elemek eltávolítása
Az általunk használt leképezések eltávolításához eltávolítás() az IdentityHashMap osztály beépített metódusa, és bármely adott kulcs leképezésének eltávolítására szolgál a térképről.

// 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. Az elemek elérése

Az IdentityHashMap elemeit a kap() módszer példáját az alábbiakban mutatjuk be.

// 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. Bejárás
Az Iterator interfész segítségével a Collection Framework bármely struktúráján áthaladhatunk. Mivel az iterátorok egy típusú adattal dolgoznak, az Entry-t használjuk< ? ? >hogy a két különálló típust kompatibilis formátumba oldja fel. Ezután a next() metódussal kinyomtatjuk az IdentityHashMap elemeit.

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

Szinkronizált IdentityHashMap

Ha több szál egyidejűleg fér hozzá egy azonosságkivonat-leképezéshez, és legalább az egyik szál szerkezetileg módosítja a leképezést, akkor külsőleg szinkronizálni kell. (Strukturális módosítás minden olyan művelet, amely egy vagy több leképezést ad hozzá vagy töröl; pusztán egy példányban már szereplő kulcshoz társított érték módosítása nem minősül szerkezeti módosításnak.) Ezt jellemzően valamilyen objektum szinkronizálásával érik el, amely természetesen magába foglalja a térképet. Ha nem létezik ilyen objektum, a térképet a következővel kell „burkolni”. Collections.synchronizedMap módszer. Ezt a legjobb a létrehozáskor megtenni, hogy elkerülje a véletlen, szinkronizálatlan hozzáférést a térképhez. 

Térkép m = Collections.synchronizedMap(new IdentityHashMap(...));

Az IdentityHashMap módszerei

K– A kulcsok típusa a térképen.V– A térképen leképezett értékek típusa.

A java.util.AbstractMap osztályban deklarált metódusok

A java.util.Map felületen deklarált módszerek

IdentityHashMap vs  HashMap

• Az IdentityHashMap a '==' egyenlőségi operátort használja a kulcsok és értékek összehasonlításához, míg a HashMap az egyenlőség módszert használja a kulcsok és értékek összehasonlításához a Map-en belül.
• Mivel az IdentityHashMap nem használja az equals()-t, viszonylag gyorsabb, mint a HashMap egy drága equals()-es objektum esetén.
• Az IdentityHashMap nem követeli meg, hogy a kulcsok megváltoztathatatlanok legyenek, mivel nem támaszkodik az equals()-re.

Az alábbi program bemutatja az IdentityHashMap és a HashMap megvalósítás közötti különbséget.

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

Az IdentityHashMap egy olyan Java osztály, amely megvalósítja a Map felületet, és referenciaegyenlőséget használ a kulcsok összehasonlításához. Hasonló a hagyományos HashMaphez, de az == operátort használja a kulcsok összehasonlítására az equals() metódus helyett. Ez azt jelenti, hogy két azonos tartalmú, de eltérő objektumhivatkozású kulcsot a rendszer külön kulcsként kezel az IdentityHashMap-ban.

Íme egy példa az IdentityHashMap használatára Java nyelven:

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 

Ebben a példában létrehozunk egy IdentityHashMap-et, amely a karakterlánc-kulcsokat egész értékekre képezi le. Két kulcs-érték párt adunk a térképhez két különböző karakterlánc objektum használatával, amelyeknek azonos a tartalma. Ezután lekérjük az értékeket a térképről ugyanazon és különböző String objektumok használatával. Azt találtuk, hogy lekérhetünk értékeket a térképről a két különböző kulcs használatával, amelyeknek ugyanaz a tartalma, de nem tudunk lekérni értéket olyan String objektum használatával, amely azonos tartalommal rendelkezik, de egy másik objektumhivatkozás.

Vegye figyelembe, hogy az IdentityHashMap viselkedése kissé eltér a hagyományos HashMap-től, és általában csak bizonyos helyzetekben hasznos, amikor a referenciaegyenlőség fontos. A legtöbb esetben egy szokásos HashMap elegendő és megfelelőbb.

kivétel dobja a javát