The IdentityHashMap īsteno Karte interfeisa izmantošana Hashtable izmantojot atsauces vienlīdzību objekta vienlīdzības vietā, salīdzinot atslēgas (un vērtības). Šī klase nav vispārējas nozīmes kartes ieviešana. Lai gan šī klase ievieš kartes saskarni, tā apzināti pārkāpj Map vispārējo līgumu, kas nosaka, ka, salīdzinot objektus, ir jāizmanto vienāds() metode. Šī klase tiek izmantota, ja lietotājs pieprasa objektus salīdzināt, izmantojot atsauci. Tas pieder java.util iepakojums.

IdentityHashMap funkcijas

• Tas seko atsauces vienlīdzībai, nevis izmanto equals() metodi, bet izmanto == operatoru.
• Tas nav sinhronizēts, un tas ir jāsinhronizē ārēji.
• Iteratori ir ātrs metiens ConcurrentModificationException mēģinot mainīt atkārtošanas laikā.
• Šī klase nodrošina pastāvīgu veiktspēju pamata operācijām (iegūt un ievietot), pieņemot, ka sistēmas identitātes jaucējfunkcija (System.identityHashCode(Object)) pareizi izkliedē elementus starp segmentiem. IdentityHashMap neizmanto metodi hashCode(), tā vietā tā izmanto metodi System.identityHashCode(). Tā ir būtiska atšķirība, jo tagad kā atslēgu kartē varat izmantot maināmus objektus, kuru jaucējkods, visticamāk, mainīsies, kad kartēšana tiek saglabāta IdentityHashMap.

Deklarācija:

publiskās klases IdentityHashMappaplašina AbstractMapievieš kartiSerializējams klonējams 
 

Šeit K ir galvenais Objekta veids un V ir vērtība Objekta tips.

Java IdentityHashMap ir klase, kas ievieš kartes saskarni. Tas ir līdzīgs HashMap klasei, un galvenā atšķirība ir tāda, ka, salīdzinot atslēgas, IdentityHashMap izmanto atsauces vienādību, nevis objektu vienlīdzību.

Lai gan HashMap atslēgu salīdzināšanai izmanto metodi equals(), IdentityHashMap izmanto == operatoru, lai salīdzinātu atslēgas. Tas nozīmē, ka IdentityHashMap divas atslēgas tiek uzskatītas par vienādām tad un tikai tad, ja tās ir viens un tas pats objekts, nevis vienādas satura ziņā.

pretrunīga meklēšana

Šeit ir piemērs tam, kā Java var izmantot 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  } } 

izvade;

2 

1

IdentityHashMap klase Java ir uz jaucējtabulu balstīta kartes interfeisa implementācija, kas, salīdzinot atslēgas (un vērtības), izmanto atsauces vienlīdzību objekta vienlīdzības vietā.

IdentityHashMap izmantošanas priekšrocības salīdzinājumā ar HashMap:

1. Ātrāka meklēšana: tā kā IdentityHashMap salīdzināšanai izmanto atsauces vienlīdzību, meklēšana ir ātrāka salīdzinājumā ar HashMap, kas izmanto objektu vienlīdzību.
2. Noderīga objektu gadījumu salīdzināšanai: IdentityHashMap ir noderīga situācijās, kad vēlaties salīdzināt objektu gadījumus, nevis objektu vērtības.

IdentityHashMap izmantošanas trūkumi:

1. Izmanto vairāk atmiņas: IdentityHashMap izmanto vairāk atmiņas salīdzinājumā ar HashMap, jo tai ir jāsaglabā atsauce uz objektu.
2. Nav piemērots visiem lietošanas gadījumiem: IdentityHashMap nav piemērots visiem lietošanas gadījumiem, un tas jāizmanto piesardzīgi, jo tas var izraisīt neparedzētu rīcību noteiktās situācijās.

IdentityHashMap hierarhija

iterējoša karte java

Tā īsteno Serializējams Klonējams Karte saskarnes un paplašina AbstractMap klasē.

Piemērs:

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

Mēs varam izveidot piemēru IdentityHashMap divos veidos:

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

1. IdentityHashMap():  Izveido jaunu tukšu identitātes jaucējkarti ar noklusējuma paredzamo maksimālo izmēru. 

IdentityHashMapviņam = jauna IdentityHashMap();

2. IdentityHashMap(int expectMaxSize):  Izveido jaunu tukšu karti ar norādīto paredzamo maksimālo izmēru. 

IdentityHashMapihm = new IdentityHashMap(int gaidītsMaxSize);

3. IdentityHashMap (karte m):  Izveido jaunu identitātes jaucējkarti, kas satur atslēgas vērtību kartējumus norādītajā kartē.

IdentityHashMapihm = new IdentityHashMap(Karte m);

IdentityHashMap pamatoperācijas

1. Elementu pievienošana

Lai ievietotu vai pievienotu kartējumu IdentityHashMap, kas mums ir likt () un likt visu() metodes. put() var ievietot noteiktu atslēgu un vērtību, ko tā kartē, noteiktā kartē. Ja tiek nodota esošā atslēga, iepriekšējā vērtība tiek aizstāta ar jauno vērtību. PutAll () kopē visus elementus, t.i., kartējumus no vienas kartes citā. 

fmovies

// 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. Elementu noņemšana
Mēs izmantojam kartējumu noņemšanai noņemt () IdentityHashMap klases iebūvēta metode un tiek izmantota, lai noņemtu jebkuras noteiktas atslēgas kartēšanu no kartes.

// 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. Piekļuve elementiem

Mēs varam piekļūt IdentityHashMap elementiem, izmantojot saņemt () metodes piemērs ir sniegts zemāk.

// 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. Traversēšana
Mēs varam izmantot Iterator saskarni, lai pārvietotos pa jebkuru kolekcijas ietvara struktūru. Tā kā iteratori strādā ar viena veida datiem, mēs izmantojam Entry< ? ? >lai atrisinātu abus atsevišķos veidus saderīgā formātā. Pēc tam, izmantojot next() metodi, mēs izdrukājam 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 

Sinhronizēta IdentityHashMap

Ja vairāki pavedieni vienlaikus piekļūst identitātes jaucējkartei un vismaz viens no pavedieniem strukturāli modificē karti, tas ir jāsinhronizē ārēji. (Strukturāla modifikācija ir jebkura darbība, kas pievieno vai dzēš vienu vai vairākus kartējumus; tikai ar instancē jau ietverto atslēgu saistītās vērtības mainīšana nav strukturāla modifikācija.) To parasti veic, sinhronizējot kādu objektu, kas dabiski iekapsulē karti. Ja šāda objekta nav, karte ir jāietver, izmantojot Collections.synchronizedMap metodi. To vislabāk var izdarīt izveides laikā, lai novērstu nejaušu nesinhronizētu piekļuvi kartei. 

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

IdentityHashMap metodes

K– taustiņu veids kartē.V– kartē kartēto vērtību veids.

Klasē java.util.AbstractMap deklarētās metodes

Interfeisā java.util.Map deklarētās metodes

IdentityHashMap vs  HashMap

• IdentityHashMap izmanto vienlīdzības operatoru '==', lai salīdzinātu atslēgas un vērtības, savukārt HashMap izmanto vienādības metodi, lai salīdzinātu atslēgas un vērtības programmā Map.
• Tā kā IdentityHashMap neizmanto equals(), tas ir salīdzinoši ātrāks nekā HashMap objektam ar dārgu vienādojumu ().
• IdentityHashMap neprasa, lai atslēgas būtu nemainīgas, jo tā netiek paļauta uz equals ().

Tālāk redzamā programma ilustrē atšķirību starp IdentityHashMap un HashMap ieviešanu.

// 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 ir Java klase, kas ievieš kartes saskarni un izmanto atsauces vienlīdzību, lai salīdzinātu atslēgas. Tas ir līdzīgs parastajam HashMap, taču tas izmanto == operatoru, lai salīdzinātu atslēgas, nevis vienādu () metodi. Tas nozīmē, ka divas atslēgas ar tādu pašu saturu, bet atšķirīgām objektu atsaucēm tiks uzskatītas par atšķirīgām atslēgām IdentityHashMap.

Šeit ir piemērs, kā izmantot IdentityHashMap 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 

Šajā piemērā mēs izveidojam IdentityHashMap, kas kartē virknes atslēgas ar veselu skaitļu vērtībām. Mēs pievienojam kartei divus atslēgu-vērtību pārus, izmantojot divus dažādus virknes objektus, kuriem ir vienāds saturs. Pēc tam mēs izgūstam vērtības no kartes, izmantojot tos pašus un dažādus virknes objektus. Mēs atklājam, ka mēs varam izgūt vērtības no kartes, izmantojot divas dažādas atslēgas, kurām ir vienāds saturs, bet mēs nevaram izgūt vērtību, izmantojot String objektu, kuram ir tāds pats saturs, bet kas ir cita objekta atsauce.

Ņemiet vērā, ka IdentityHashMap darbība nedaudz atšķiras no parastās HashMap un parasti ir noderīga tikai noteiktās situācijās, kad ir svarīga atsauces vienlīdzība. Vairumā gadījumu parastā HashMap ir pietiekama un piemērotāka.

c++ int uz virkni