De IdentityHashMap redskaper Kart grensesnitt ved hjelp av Hastbar ved å bruke referanselikhet i stedet for objektlikhet når man sammenligner nøkler (og verdier). Denne klassen er ikke en generell kartimplementering. Mens denne klassen implementerer Map-grensesnittet, bryter den med hensikt Maps generelle kontrakt som krever bruk av equals()-metoden ved sammenligning av objekter. Denne klassen brukes når brukeren krever at objektene skal sammenlignes via referanse. Det tilhører java.util pakke.

Funksjoner av IdentityHashMap

• Den følger referanselikhet i stedet for å bruke equals()-metoden, den bruker ==-operatoren.
• Den er ikke synkronisert og må synkroniseres eksternt.
• Iteratorer er feil-raske kast ConcurrentModificationException i et forsøk på å endre mens du itererer.
• Denne klassen gir konstant-tidsytelse for de grunnleggende operasjonene (get og put) forutsatt at systemidentitet-hash-funksjonen (System.identityHashCode(Object)) sprer elementene riktig blant bøttene. IdentityHashMap bruker ikke hashCode()-metoden i stedet for System.identityHashCode()-metoden. Dette er en betydelig forskjell fordi nå kan du bruke mutable objekter som nøkkel i Map hvis hash-kode sannsynligvis vil endres når kartleggingen er lagret i IdentityHashMap.

Erklæring:

offentlig klasse IdentityHashMaputvider AbstractMapimplementerer KartSerialiserbar Klonbar 
 

Her K er nøkkelen Objekttype og V er verdien Objekttype.

I Java er IdentityHashMap en klasse som implementerer kartgrensesnittet. Den ligner på HashMap-klassen, med hovedforskjellen at IdentityHashMap bruker referanselikhet i stedet for objektlikhet når man sammenligner nøkler.

Mens HashMap bruker equals()-metoden for å sammenligne nøklene, bruker IdentityHashMap operatoren == for å sammenligne nøklene. Dette betyr at i en IdentityHashMap anses to nøkler som like hvis og bare hvis de er det samme objektet i stedet for å være like når det gjelder innholdet.

hvor mange byer er det i USA

Her er et eksempel på hvordan du kan bruke et IdentityHashMap i 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  } } 

produksjon;

2 

1

IdentityHashMap-klassen i Java er en hashtabellbasert implementering av Map-grensesnittet som bruker referanselikhet i stedet for objektlikhet ved sammenligning av nøkler (og verdier).

Fordeler med å bruke IdentityHashMap fremfor HashMap:

1. Raskere oppslag: Siden IdentityHashMap bruker referanselikhet for sammenligning, er det raskere for oppslag sammenlignet med HashMap som bruker objektlikhet.
2. Nyttig for å sammenligne objektforekomster: IdentityHashMap er nyttig i situasjoner der du ønsker å sammenligne objektforekomster i stedet for objektverdier.

Ulemper med å bruke IdentityHashMap:

1. Bruker mer minne: IdentityHashMap bruker mer minne sammenlignet med HashMap da den trenger å lagre referansen til objektet.
2. Ikke egnet for alle brukstilfeller: IdentityHashMap er ikke egnet for alle brukstilfeller og bør brukes med forsiktighet da det kan føre til uventet oppførsel i visse situasjoner.

Hierarki av IdentityHashMap

Den gjennomfører Serialiserbar Klonbar Kart grensesnitt og utvider Abstrakt kart klasse.

Eksempel:

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

Konstruktører av IdentityHashMap

Vi kan lage en forekomst av IdentityHashMap på to måter:

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

1. IdentityHashMap():  Konstruerer et nytt tomt identitets-hashkart med en standard forventet maksimal størrelse. 

java hello world eksempel

IdentityHashMapham = nytt IdentityHashMap();

2. IdentityHashMap(int forventetMaxSize):  Konstruerer et nytt tomt kart med angitt forventet maksimal størrelse. 

IdentityHashMapihm = new IdentityHashMap(int forventetMaxSize);

3. IdentityHashMap(Kart m):  Konstruerer et nytt hash-kart for identitet som inneholder nøkkelverdi-tilordningene i det angitte kartet.

IdentityHashMapihm = new IdentityHashMap(Map m);

Grunnleggende operasjoner på IdentityHashMap

1. Legge til elementer

For å sette inn eller legge til kartlegging i et IdentityHashMap har vi sette() og putAll() metoder. put() kan sette inn en spesifikk nøkkel og verdien den tilordner til et bestemt kart. Hvis en eksisterende nøkkel sendes, blir den forrige verdien erstattet av den nye verdien. putAll() kopierer alle elementene, dvs. tilordningene fra ett kart til et annet. 

// 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. Fjerning av elementer
For å fjerne kartlegginger bruker vi fjerne() en innebygd metode for IdentityHashMap-klassen og brukes til å fjerne tilordningen av en bestemt nøkkel fra kartet.

java pseudokode

// 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. Få tilgang til elementene

Vi kan få tilgang til elementene i et IdentityHashMap ved å bruke bli() metode eksemplet på dette er gitt nedenfor.

// 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. Traversering
Vi kan bruke Iterator-grensesnittet til å krysse en hvilken som helst struktur i innsamlingsrammen. Siden iteratorer jobber med én type data, bruker vi Entry< ? ? >for å løse de to separate typene til et kompatibelt format. Ved å bruke neste()-metoden skriver vi ut elementene i 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 

Synchronized IdentityHashMap

Hvis flere tråder får tilgang til et identitets-hash-kart samtidig og minst én av trådene endrer kartet strukturelt, må det synkroniseres eksternt. (En strukturell modifikasjon er enhver operasjon som legger til eller sletter en eller flere tilordninger; bare å endre verdien knyttet til en nøkkel som en forekomst allerede inneholder, er ikke en strukturell modifikasjon.) Dette oppnås vanligvis ved å synkronisere på et objekt som naturlig innkapsler kartet. Hvis det ikke finnes noe slikt objekt, bør kartet "pakkes inn" ved hjelp av Collections.synchronizedMap metode. Dette gjøres best på opprettelsestidspunktet for å forhindre utilsiktet usynkronisert tilgang til kartet. 

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

Metoder for IdentityHashMap

K– Typen av nøklene i kartet.V– Type verdier kartlagt i kartet.

Metoder deklarert i klassen java.util.AbstractMap

Metoder deklarert i grensesnittet java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap bruker likhetsoperatoren '==' for å sammenligne nøkler og verdier mens HashMap bruker likhetsmetoden for å sammenligne nøkler og verdier inne i Map.
• Siden IdentityHashMap ikke bruker equals(), er det relativt raskere enn HashMap for et objekt med dyre equals().
• IdentityHashMap krever ikke at nøkler skal være uforanderlige siden det ikke er avhengig av equals().

Programmet nedenfor illustrerer forskjellen mellom IdentityHashMap og HashMap-implementering.

// 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 er en klasse i Java som implementerer kartgrensesnittet og bruker referanselikhet for å sammenligne nøkler. Det ligner på et vanlig HashMap, men det bruker ==-operatoren for å sammenligne nøkler i stedet for equals()-metoden. Dette betyr at to nøkler med samme innhold men forskjellige objektreferanser vil bli behandlet som distinkte nøkler i et IdentityHashMap.

Her er et eksempel på hvordan du bruker IdentityHashMap i 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 

I dette eksemplet lager vi et IdentityHashMap som kartlegger strengnøkler til heltallsverdier. Vi legger til to nøkkelverdi-par til kartet ved å bruke to forskjellige strengobjekter som har samme innhold. Vi henter deretter verdier fra kartet ved å bruke samme og forskjellige String-objekter. Vi finner ut at vi kan hente verdier fra kartet ved å bruke de to forskjellige nøklene som har samme innhold, men vi kan ikke hente en verdi ved å bruke et String-objekt som har samme innhold, men som er en annen objektreferanse.

Merk at IdentityHashMap har en litt annen oppførsel enn et vanlig HashMap og er generelt bare nyttig i visse situasjoner der referanselikhet er viktig. I de fleste tilfeller er et vanlig HashMap tilstrekkelig og mer hensiktsmessig.

concat java-streng