The IdentityHashMap padargai Žemėlapis naudojant sąsają Hashtable lyginant raktus (ir reikšmes), vietoj objekto lygybės naudojant nuorodos lygybę. Ši klasė nėra bendros paskirties žemėlapio diegimas. Nors ši klasė įgyvendina žemėlapio sąsają, ji tyčia pažeidžia Žemėlapio bendrąją sutartį, kuri įpareigoja naudoti lygių () metodą lyginant objektus. Ši klasė naudojama, kai vartotojas reikalauja, kad objektai būtų lyginami naudojant nuorodą. Tai priklauso java.util paketą.

„IdentityHashMap“ ypatybės

• Jis vadovaujasi nuorodos lygybe, užuot naudojęs equals() metodą, naudoja operatorių ==.
• Jis nėra sinchronizuotas ir turi būti sinchronizuojamas išorėje.
• Iteratoriai yra greitai išmesti ConcurrentModificationException bandant pakeisti kartojimo metu.
• Ši klasė užtikrina nuolatinį pagrindinių operacijų (gauti ir įdėti) našumą, darant prielaidą, kad sistemos tapatybės maišos funkcija (System.identityHashCode(Object)) tinkamai paskirsto elementus tarp segmentų. IdentityHashMap nenaudoja hashCode() metodo, o naudoja System.identityHashCode() metodą. Tai reikšmingas skirtumas, nes dabar kaip raktą Žemėlapyje galite naudoti kintamus objektus, kurių maišos kodas gali pasikeisti, kai atvaizdas bus saugomas „IdentityHashMap“.

Deklaracija:

viešoji klasė „IdentityHashMap“.pratęsia AbstractMapįgyvendina ŽemėlapįSerializuojamas klonuojamas 
 

Čia K yra pagrindinis objekto tipas ir V yra reikšmė Objekto tipas.

Java IdentityHashMap yra klasė, kuri įgyvendina žemėlapio sąsają. Jis panašus į „HashMap“ klasę, o pagrindinis skirtumas yra tas, kad „IdentityHashMap“ lygindama raktus naudoja nuorodos lygybę, o ne objektų lygybę.

Nors „HashMap“ raktams palyginti naudoja „ equals“ () metodą, „IdentityHashMap“ raktams palyginti naudoja operatorių ==. Tai reiškia, kad „IdentityHashMap“ du raktai laikomi lygiais tada ir tik tada, kai jie yra tas pats objektas, o ne lygūs savo turiniu.

Parsisiųsti youtube vaizdo įrašus į vlc

Štai pavyzdys, kaip „Java“ galite naudoti „IdentityHashMap“:

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

išvestis;

2 

1

„Java“ „IdentityHashMap“ klasė yra maišos lentelės pagrindu sukurtas žemėlapio sąsajos įgyvendinimas, kuriame lyginant raktus (ir reikšmes) vietoj objekto lygybės naudojama nuorodų lygybė.

„IdentityHashMap“ naudojimo pranašumai, palyginti su „HashMap“:

1. Greitesnės paieškos: kadangi „IdentityHashMap“ palyginimui naudoja nuorodų lygybę, ji yra greitesnė, palyginti su „HashMap“, kuri naudoja objektų lygybę.
2. Naudinga lyginant objektų egzempliorius: „IdentityHashMap“ yra naudinga tais atvejais, kai norite palyginti objektų egzempliorius, o ne objektų reikšmes.

„IdentityHashMap“ naudojimo trūkumai:

1. Naudoja daugiau atminties: „IdentityHashMap“ naudoja daugiau atminties, palyginti su „HashMap“, nes jai reikia saugoti nuorodą į objektą.
2. Netinka visiems naudojimo atvejams: „IdentityHashMap“ netinka visiems naudojimo atvejams ir turėtų būti naudojamas atsargiai, nes tam tikrose situacijose tai gali sukelti netikėtą elgesį.

„IdentityHashMap“ hierarchija

Tai įgyvendina Serializuojama Galima klonuoti Žemėlapis sąsajas ir išplečia AbstractMap klasė.

Pavyzdys:

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

„IdentityHashMap“ konstruktoriai

Galime sukurti egzempliorių IdentityHashMap dviem būdais:

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

1. IdentityHashMap():  Sukuria naują tuščią tapatybės maišos žemėlapį su numatytuoju numatomu didžiausiu dydžiu. 

IdentityHashMapjis = naujas IdentityHashMap();

2. IdentityHashMap (int tikimasiMaxSize):  Sukuria naują tuščią žemėlapį su nurodytu numatomu didžiausiu dydžiu. 

IdentityHashMapihm = new IdentityHashMap(int tikimasiMaxSize);

Salman Khan Khan amžius

3. IdentityHashMap (žemėlapis m):  Sukuria naują tapatybės maišos žemėlapį, kuriame yra rakto-reikšmių susiejimas nurodytame žemėlapyje.

IdentityHashMapihm = naujas IdentityHashMap (žemėlapis m);

Pagrindinės operacijos „IdentityHashMap“.

1. Elementų pridėjimas

xd prasmė

Norėdami įterpti arba įtraukti atvaizdą į „IdentityHashMap“, turime įdėti () ir įdėti viską () metodus. put() gali įterpti konkretų raktą ir jo priskirtą reikšmę į tam tikrą žemėlapį. Jei perduodamas esamas raktas, ankstesnė vertė pakeičiama nauja. putAll () nukopijuoja visus elementus, ty atvaizdus iš vieno žemėlapio į kitą. 

// 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. Elementų pašalinimas
Norėdami pašalinti atvaizdus, ​​kuriuos naudojame pašalinti () integruotas IdentityHashMap klasės metodas ir naudojamas pašalinti bet kurio konkretaus rakto atvaizdavimą iš žemėlapio.

// 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. Prieiga prie elementų

„IdentityHashMap“ elementus galime pasiekti naudodami gauti () Šio metodo pavyzdys pateiktas žemiau.

// 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. Traversavimas
Galime naudoti „Iterator“ sąsają, norėdami pereiti per bet kurią kolekcijos struktūrą. Kadangi Iteratoriai dirba su vieno tipo duomenimis, naudojame Entry< ? ? >kad išskirstytumėte du atskirus tipus į suderinamą formatą. Tada naudodami next() metodą spausdiname IdentityHashMap elementus.

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

Sinchronizuotas IdentityHashMap

Jei kelios gijos vienu metu pasiekia tapatybės maišos žemėlapį ir bent viena iš gijų struktūriškai modifikuoja žemėlapį, ji turi būti sinchronizuota išoriškai. (Struktūrinis modifikavimas yra bet kokia operacija, kuri prideda arba ištrina vieną ar daugiau atvaizdų; vien tik su egzemplioriuje esančiu raktu susietos reikšmės pakeitimas nėra struktūrinis modifikavimas.) Paprastai tai atliekama sinchronizuojant su kokiu nors objektu, kuris natūraliai apima žemėlapį. Jei tokio objekto nėra, žemėlapis turėtų būti „apvyniotas“ naudojant Kolekcijos.synchronizedMap metodas. Tai geriausia padaryti kuriant, kad išvengtumėte atsitiktinės nesinchronizuotos prieigos prie žemėlapio. 

Žemėlapis m = Collections.synchronizedMap(new IdentityHashMap(...));

IdentityHashMap metodai

K– klavišų tipas žemėlapyje.V– Žemėlapyje susietų verčių tipas.

Metodai, deklaruoti klasėje java.util.AbstractMap

Metodai, nurodyti sąsajoje java.util.Map

IdentityHashMap vs  HashMap

• „IdentityHashMap“ raktams ir reikšmėms lyginti naudoja lygybės operatorių „==“, o „HashMap“ naudoja lygių metodą raktams ir reikšmėms lyginti žemėlapyje.
• Kadangi „IdentityHashMap“ nenaudoja equals(), jis yra palyginti greitesnis nei „HashMap“ objektui su brangiu equals ().
• „IdentityHashMap“ nereikalauja, kad raktai būtų nekintami, nes jis nėra pagrįstas „ equals ().

Žemiau pateikta programa parodo skirtumą tarp „IdentityHashMap“ ir „HashMap“ diegimo.

// 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“ yra „Java“ klasė, kuri įgyvendina žemėlapio sąsają ir naudoja nuorodų lygybę raktams palyginti. Jis panašus į įprastą HashMap, tačiau raktams lyginti naudojamas operatorius ==, o ne lygis () metodas. Tai reiškia, kad du raktai su tuo pačiu turiniu, bet skirtingomis objektų nuorodomis bus traktuojami kaip skirtingi raktai „IdentityHashMap“.

Štai pavyzdys, kaip „Java“ naudoti „IdentityHashMap“:

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 

Šiame pavyzdyje sukuriame IdentityHashMap, kuris susieja String raktus su sveikųjų skaičių reikšmėmis. Prie žemėlapio pridedame dvi raktų ir reikšmių poras, naudodami du skirtingus eilutės objektus, kurių turinys yra toks pat. Tada iš žemėlapio gauname reikšmes naudodami tuos pačius ir skirtingus eilutės objektus. Pastebime, kad galime gauti reikšmes iš žemėlapio naudodami du skirtingus raktus, kurių turinys yra toks pat, bet negalime gauti reikšmės naudodami objektą String, kurio turinys yra toks pat, bet yra kitokia objekto nuoroda.

Atminkite, kad „IdentityHashMap“ veikia šiek tiek kitaip nei įprastas „HashMap“ ir paprastai yra naudingas tik tam tikrose situacijose, kai svarbi nuorodų lygybė. Daugeliu atvejų įprasto HashMap pakanka ir tinkamesnis.

10 iš 100