De IdentityHashMap redskaber Kort interface ved hjælp af Hastbar ved at bruge reference-lighed i stedet for objekt-lighed ved sammenligning af nøgler (og værdier). Denne klasse er ikke en generel kortimplementering. Mens denne klasse implementerer kortgrænsefladen, overtræder den med vilje Maps generelle kontrakt, som påbyder brugen af ​​equals()-metoden ved sammenligning af objekter. Denne klasse bruges, når brugeren kræver, at objekterne sammenlignes via reference. Det hører til java.util pakke.

Funktioner i IdentityHashMap

• Den følger reference-lighed i stedet for at bruge equals()-metoden, den bruger ==-operatoren.
• Den er ikke synkroniseret og skal synkroniseres eksternt.
• Iteratorer er fejl-hurtige kast ConcurrentModificationException i et forsøg på at ændre under iteration.
• Denne klasse giver konstant-tidsydelse for de grundlæggende operationer (get og put), forudsat at systemidentitets-hash-funktionen (System.identityHashCode(Object)) spreder elementer korrekt blandt buckets. IdentityHashMap bruger ikke hashCode()-metoden i stedet for System.identityHashCode()-metoden. Dette er en væsentlig forskel, fordi nu kan du bruge mutable objekter som nøgle i Map, hvis hash-kode sandsynligvis vil ændre sig, når kortlægningen er gemt i IdentityHashMap.

Erklæring:

offentlig klasse IdentityHashMapudvider AbstractMapimplementerer KortSerialiserbar Klonbar 
 

Her K er nøgleobjekttypen og V er værdien Objekttype.

I Java er IdentityHashMap en klasse, der implementerer kortgrænsefladen. Det ligner HashMap-klassen med den største forskel er, at IdentityHashMap bruger referencelighed i stedet for objektlighed, når man sammenligner nøgler.

Mens HashMap bruger metoden equals() til at sammenligne nøglerne, bruger IdentityHashMap operatoren == til at sammenligne nøglerne. Det betyder, at i et IdentityHashMap anses to nøgler for at være lige, hvis og kun hvis de er det samme objekt i stedet for at være ens med hensyn til deres indhold.

hvor mange byer er der i USA

Her er et eksempel på, hvordan du kan bruge 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  } } 

produktion;

2 

1

IdentityHashMap-klassen i Java er en hash-tabel-baseret implementering af kortgrænsefladen, der bruger reference-lighed i stedet for objekt-lighed, når nøgler (og værdier) sammenlignes.

Fordele ved at bruge IdentityHashMap over HashMap:

1. Hurtigere opslag: Da IdentityHashMap bruger reference-lighed til sammenligning, er det hurtigere for opslag sammenlignet med HashMap, som bruger objekt-lighed.
2. Nyttigt til at sammenligne objektforekomster: IdentityHashMap er nyttigt i situationer, hvor du ønsker at sammenligne objektforekomster i stedet for objektværdier.

Ulemper ved at bruge IdentityHashMap:

1. Bruger mere hukommelse: IdentityHashMap bruger mere hukommelse sammenlignet med HashMap, da det skal gemme referencen til objektet.
2. Ikke egnet til alle use cases: IdentityHashMap er ikke egnet til alle use cases og bør bruges med forsigtighed, da det kan føre til uventet adfærd i visse situationer.

Hierarki af IdentityHashMap

Det gennemfører Serialiserbar Kan klones Kort grænseflader og udvider Abstrakt kort 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 af IdentityHashMap

Vi kan oprette en instans af IdentityHashMap på to måder:

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

1. IdentityHashMap():  Konstruerer et nyt tomt identitets-hash-kort med en standard forventet maksimal størrelse. 

vælg sql fra flere tabeller

IdentityHashMapham = nyt IdentityHashMap();

2. IdentityHashMap(int forventetMaxSize):  Konstruerer et nyt tomt kort med den angivne forventede maksimale størrelse. 

IdentityHashMapihm = new IdentityHashMap(int forventetMaxSize);

3. IdentityHashMap(Map m):  Konstruerer et nyt identitets-hash-kort, der indeholder nøgleværdi-tilknytningerne i det angivne kort.

IdentityHashMapihm = new IdentityHashMap(Map m);

Grundlæggende handlinger på IdentityHashMap

1. Tilføjelse af elementer

For at indsætte eller tilføje kortlægning i et IdentityHashMap har vi sætte() og putAll() metoder. put() kan indsætte en specifik nøgle og den værdi, den tilknytter til et bestemt kort. Hvis en eksisterende nøgle videregives, bliver den tidligere værdi erstattet af den nye værdi. putAll() kopierer alle elementerne, dvs. tilknytningerne fra et kort til et andet. 

// 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. Fjernelse af elementer
For at fjerne kortlægninger bruger vi fjerne() en indbygget metode af IdentityHashMap-klassen og bruges til at fjerne tilknytningen af ​​en bestemt nøgle fra kortet.

java cast char til streng

// 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. Adgang til elementerne

Vi kan få adgang til elementerne i et IdentityHashMap ved hjælp af få() metode eksemplet på dette er givet 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 bruge Iterator-grænsefladen til at krydse enhver struktur i Collection Framework. Da iteratorer arbejder med én type data, bruger vi Entry< ? ? >for at løse de to separate typer til et kompatibelt format. Ved hjælp af næste()-metoden udskriver vi elementerne 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 

Synkroniseret IdentityHashMap

Hvis flere tråde får adgang til et identitets-hash-kort samtidigt, og mindst én af trådene ændrer kortet strukturelt, skal det synkroniseres eksternt. (En strukturel ændring er enhver handling, der tilføjer eller sletter en eller flere tilknytninger; blot at ændre værdien forbundet med en nøgle, som en instans allerede indeholder, er ikke en strukturel ændring.) Dette opnås typisk ved at synkronisere på et objekt, der naturligt indkapsler kortet. Hvis der ikke findes et sådant objekt, skal kortet 'indpakkes' ved hjælp af Collections.synchronizedMap metode. Dette gøres bedst på oprettelsestidspunktet for at forhindre utilsigtet usynkroniseret adgang til kortet. 

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

Metoder til IdentityHashMap

K– Typen af ​​tasterne på kortet.V– Den type værdier, der er kortlagt på kortet.

Metoder erklæret i klassen java.util.AbstractMap

Metoder erklæret i interface java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap bruger lighedsoperatoren '==' til at sammenligne nøgler og værdier, mens HashMap bruger equals-metoden til at sammenligne nøgler og værdier inde i Map.
• Da IdentityHashMap ikke bruger equals(), er det forholdsvis hurtigere end HashMap for et objekt med dyre equals().
• IdentityHashMap kræver ikke, at nøgler er uforanderlige, da det ikke er afhængigt af equals().

Nedenstående program illustrerer forskellen mellem 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, der implementerer kortgrænsefladen og bruger referencelighed til at sammenligne nøgler. Det ligner et almindeligt HashMap, men det bruger ==-operatoren til at sammenligne nøgler i stedet for equals()-metoden. Det betyder, at to nøgler med det samme indhold, men forskellige objektreferencer, vil blive behandlet som særskilte nøgler i et IdentityHashMap.

Her er et eksempel på, hvordan du bruger 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 eksempel opretter vi et IdentityHashMap, der kortlægger strengnøgler til heltalsværdier. Vi tilføjer to nøgleværdi-par til kortet ved hjælp af to forskellige String-objekter, der har det samme indhold. Vi henter derefter værdier fra kortet ved hjælp af de samme og forskellige String-objekter. Vi finder ud af, at vi kan hente værdier fra kortet ved hjælp af de to forskellige nøgler, der har det samme indhold, men vi kan ikke hente en værdi ved hjælp af et String-objekt, der har det samme indhold, men som er en anden objektreference.

Bemærk, at IdentityHashMap har en lidt anderledes adfærd end et almindeligt HashMap og generelt kun er nyttigt i visse situationer, hvor referencelighed er vigtig. I de fleste tilfælde er et almindeligt HashMap tilstrækkeligt og mere passende.

concat java streng