The IdentityHashMap pripomočke Zemljevid uporaba vmesnika Razpršitvena tabela uporaba referenčne enakosti namesto objektne enakosti pri primerjavi ključev (in vrednosti). Ta razred ni implementacija zemljevida za splošne namene. Čeprav ta razred implementira vmesnik Map, namenoma krši splošno pogodbo Map, ki zahteva uporabo metode equals() pri primerjavi predmetov. Ta razred se uporablja, ko uporabnik zahteva, da se predmeti primerjajo prek reference. Pripada java.util paket.

Funkcije IdentityHashMap

• Sledi referenčni enakosti, namesto uporabe metode equals() uporablja operator ==.
• Ni sinhroniziran in ga je treba sinhronizirati zunaj.
• Iteratorji so fail-fast throw ConcurrentModificationException v poskusu spreminjanja med ponavljanjem.
• Ta razred zagotavlja zmogljivost v stalnem času za osnovne operacije (get in put) ob predpostavki, da funkcija zgoščevanja sistemske identitete (System.identityHashCode(Object)) pravilno razprši elemente med vedri. IdentityHashMap ne uporablja metode hashCode(), namesto tega uporablja metodo System.identityHashCode(). To je bistvena razlika, saj lahko zdaj kot ključ v Map uporabite spremenljive predmete, katerih zgoščena koda se bo verjetno spremenila, ko je preslikava shranjena znotraj IdentityHashMap.

Izjava:

javni razred IdentityHashMaprazširja AbstractMapizvaja MapSerializable Cloneable 
 

Tukaj K je ključna vrsta predmeta in V je vrednost Tip predmeta.

V Javi je IdentityHashMap razred, ki implementira vmesnik Map. Podoben je razredu HashMap, glavna razlika pa je v tem, da IdentityHashMap pri primerjavi ključev uporablja referenčno enakost namesto objektne enakosti.

Medtem ko HashMap za primerjavo ključev uporablja metodo equals(), IdentityHashMap za primerjavo ključev uporablja operator ==. To pomeni, da se v IdentityHashMap dva ključa štejeta za enaka, če in samo če sta isti objekt in ne enaka glede na vsebino.

negacija diskretne matematike

Tukaj je primer, kako lahko uporabite IdentityHashMap v Javi:

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

izhod;

2 

1

Razred IdentityHashMap v Javi je izvedba vmesnika Map, ki temelji na zgoščevalni tabeli in pri primerjavi ključev (in vrednosti) namesto enakosti objektov uporablja referenčno enakost.

Prednosti uporabe IdentityHashMap pred HashMap:

1. Hitrejša iskanja: Ker IdentityHashMap za primerjavo uporablja referenčno enakost, je iskanje hitrejše v primerjavi s HashMap, ki uporablja enakost objektov.
2. Uporabno za primerjavo primerkov objektov: IdentityHashMap je uporaben v primerih, ko želite primerjati primerke objektov in ne vrednosti objektov.

Slabosti uporabe IdentityHashMap:

1. Uporablja več pomnilnika: IdentityHashMap uporablja več pomnilnika v primerjavi s HashMap, saj mora shraniti sklic na predmet.
2. Ni primeren za vse primere uporabe: IdentityHashMap ni primeren za vse primere uporabe in ga je treba uporabljati previdno, saj lahko v določenih situacijah povzroči nepričakovano vedenje.

Hierarhija IdentityHashMap

Izvaja Serializable Klonirati Zemljevid vmesniki in razširitve AbstractMap razred.

primer:

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

Konstruktorji IdentityHashMap

Ustvarimo lahko primerek IdentityHashMap na dva načina:

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

1. IdentityHashMap():  Izdela nov prazen zgoščeni zemljevid identitete s privzeto pričakovano največjo velikostjo. 

IdentityHashMapon = nov IdentityHashMap();

2. IdentityHashMap(int pričakovana največja velikost):  Izdela nov prazen zemljevid s podano pričakovano največjo velikostjo. 

b+ drevesa

IdentityHashMapihm = nova IdentityHashMap(int pričakovana največja velikost);

3. IdentityHashMap(Map m):  Izdela novo zgoščeno preslikavo identitete, ki vsebuje preslikave ključa in vrednosti v podani preslikavi.

IdentityHashMapihm = new IdentityHashMap(Map m);

Osnovne operacije na IdentityHashMap

1. Dodajanje elementov

Za vstavljanje ali dodajanje preslikave v IdentityHashMap imamo daj() in dajVse() metode. put() lahko vstavi določen ključ in vrednost, ki jo preslika v določen zemljevid. Če je predan obstoječi ključ, se prejšnja vrednost nadomesti z novo vrednostjo. putAll() kopira vse elemente, tj. preslikave iz enega zemljevida v drugega. 

// 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. Odstranjevanje elementov
Za odstranjevanje preslikav, ki jih uporabljamo odstrani() vgrajena metoda razreda IdentityHashMap in se uporablja za odstranitev preslikave katerega koli določenega ključa s preslikave.

// 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. Dostop do elementov

Do elementov IdentityHashMap lahko dostopamo z uporabo dobiti () Metoda je primer tega podan spodaj.

// 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. Prečenje
Z vmesnikom Iterator lahko prečkamo katero koli strukturo ogrodja zbirke. Ker Iteratorji delajo z eno vrsto podatkov, uporabljamo Entry< ? ? >za razrešitev dveh ločenih vrst v združljivo obliko. Nato z uporabo metode next() natisnemo elemente 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 

Sinhronizirani IdentityHashMap

datotečni sistem linux

Če več niti istočasno dostopa do preslikave zgoščenih identitet in vsaj ena od niti strukturno spremeni preslikavo, jo je treba sinhronizirati zunaj. (Strukturna sprememba je vsaka operacija, ki doda ali izbriše eno ali več preslikav; samo spreminjanje vrednosti, povezane s ključem, ki ga primerek že vsebuje, ni strukturna sprememba.) To se običajno doseže s sinhronizacijo na nekem objektu, ki naravno ujema preslikavo. Če tak objekt ne obstaja, je treba zemljevid "zaviti" z uporabo Collections.synchronizedMap metoda. To je najbolje narediti med ustvarjanjem, da preprečite nenamerni nesinhroniziran dostop do zemljevida. 

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

Metode IdentityHashMap

K– Vrsta ključev na zemljevidu.V– Vrsta vrednosti, preslikanih na zemljevidu.

Metode, deklarirane v razredu java.util.AbstractMap

Metode, deklarirane v vmesniku java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap uporablja operator enakosti '==' za primerjavo ključev in vrednosti, medtem ko HashMap uporablja metodo equals za primerjavo ključev in vrednosti znotraj Zemljevida.
• Ker IdentityHashMap ne uporablja equals(), je sorazmerno hitrejši od HashMap za objekt z dragim equals().
• IdentityHashMap ne zahteva, da so ključi nespremenljivi, saj se ne zanaša na equals().

Spodnji program prikazuje razliko med izvedbo IdentityHashMap in 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 razred v Javi, ki implementira vmesnik Map in uporablja referenčno enakost za primerjavo ključev. Podoben je navadnemu HashMapu, vendar za primerjavo ključev uporablja operator == namesto metode equals(). To pomeni, da bosta dva ključa z enako vsebino, vendar različnimi referencami objektov obravnavana kot različna ključa v IdentityHashMap.

Tu je primer uporabe IdentityHashMap v Javi:

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 tem primeru ustvarimo IdentityHashMap, ki preslika nizovne ključe v vrednosti Integer. Na zemljevid dodamo dva para ključ-vrednost z uporabo dveh različnih objektov String z enako vsebino. Nato pridobimo vrednosti iz zemljevida z uporabo istih in različnih objektov String. Ugotovimo, da lahko pridobimo vrednosti iz zemljevida z uporabo dveh različnih ključev, ki imata isto vsebino, vendar ne moremo pridobiti vrednosti z uporabo objekta String, ki ima enako vsebino, vendar je različna referenca objekta.

Upoštevajte, da ima IdentityHashMap nekoliko drugačno obnašanje kot običajni HashMap in je na splošno uporaben samo v določenih situacijah, kjer je pomembna referenčna enakost. V večini primerov je običajni HashMap zadosten in bolj primeren.

označevalni html