De IdentityHashMap redskap Karta gränssnitt använder Hastbar använder referenslikhet i stället för objektlikhet vid jämförelse av nycklar (och värden). Den här klassen är inte en generell kartimplementering. Medan den här klassen implementerar Map-gränssnittet bryter den avsiktligt mot Maps allmänna kontrakt som kräver användning av equals()-metoden vid jämförelse av objekt. Denna klass används när användaren kräver att objekten jämförs via referens. Den tillhör java.util paket.

Funktioner i IdentityHashMap

• Den följer referenslikhet istället för att använda metoden equals() den använder operatorn ==.
• Den är inte synkroniserad och måste synkroniseras externt.
• Iteratorer är misslyckade kast ConcurrentModificationException i ett försök att ändra under iteration.
• Den här klassen tillhandahåller prestanda i konstant tid för de grundläggande operationerna (get och put) förutsatt att systemidentitetshashfunktionen (System.identityHashCode(Object)) sprider element ordentligt bland hinkarna. IdentityHashMap använder inte metoden hashCode() istället använder den metoden System.identityHashCode(). Detta är en betydande skillnad eftersom du nu kan använda föränderliga objekt som nyckel i Map vars hashkod sannolikt kommer att ändras när kartläggningen lagras i IdentityHashMap.

Förklaring:

public class IdentityHashMaputökar AbstractMapimplementerar KartaSerialiserbar Klonbar 
 

Här K är nyckelobjekttypen och V är värdet Objekttyp.

I Java är IdentityHashMap en klass som implementerar kartgränssnittet. Den liknar HashMap-klassen med den största skillnaden är att IdentityHashMap använder referenslikhet istället för objektlikhet när man jämför nycklar.

Medan HashMap använder metoden equals() för att jämföra nycklarna, använder IdentityHashMap operatorn == för att jämföra nycklarna. Detta innebär att i en IdentityHashMap anses två nycklar vara lika om och endast om de är samma objekt snarare än att vara lika vad gäller deras innehåll.

urfi javed

Här är ett exempel på hur du kan använda en 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

Klassen IdentityHashMap i Java är en hashtabellbaserad implementering av Map-gränssnittet som använder referenslikhet i stället för objektlikhet vid jämförelse av nycklar (och värden).

Fördelar med att använda IdentityHashMap över HashMap:

1. Snabbare uppslagningar: Eftersom IdentityHashMap använder referenslikhet för jämförelse är det snabbare för uppslagningar jämfört med HashMap som använder objektlikhet.
2. Användbart för att jämföra objektinstanser: IdentityHashMap är användbart i situationer där du vill jämföra objektinstanser snarare än objektvärden.

Nackdelar med att använda IdentityHashMap:

1. Använder mer minne: IdentityHashMap använder mer minne jämfört med HashMap eftersom det behöver lagra referensen till objektet.
2. Inte lämplig för alla användningsfall: IdentityHashMap är inte lämplig för alla användningsfall och bör användas med försiktighet eftersom det kan leda till oväntat beteende i vissa situationer.

Hierarkin för IdentityHashMap

Den genomför Serialiserbar Klonbar Karta gränssnitt och utökar Abstrakt karta klass.

Exempel:

// 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 skapa en instans av IdentityHashMap på två sätt:

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

1. IdentityHashMap():  Konstruerar en ny tom identitets-hashkarta med en förväntad standardstorlek. 

IdentityHashMaphonom = ny IdentityHashMap();

typ i java

2. IdentityHashMap(int expectedMaxSize):  Konstruerar en ny tom karta med den angivna förväntade maximala storleken. 

IdentityHashMapihm = new IdentityHashMap(int förväntadMaxSize);

3. IdentityHashMap(Map m):  Konstruerar en ny identitetshash-karta som innehåller nyckel-värde-mappningarna i den angivna kartan.

IdentityHashMapihm = new IdentityHashMap(Map m);

Grundläggande operationer på IdentityHashMap

1. Lägga till element

För att infoga eller lägga till mappning i en IdentityHashMap har vi sätta() och putAll() metoder. put() kan infoga en specifik nyckel och värdet den mappar till en viss karta. Om en befintlig nyckel skickas ersätts det tidigare värdet av det nya värdet. putAll() kopierar alla element, dvs mappningarna från en karta till en annan. 

// 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. Ta bort element
För att ta bort mappningar använder vi ta bort() en inbyggd metod för IdentityHashMap-klassen och används för att ta bort mappningen av en viss nyckel från kartan.

// 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. Åtkomst till elementen

Vi kan komma åt elementen i en IdentityHashMap med hjälp av få() metod exemplet på detta ges nedan.

hur många 0 i en miljard

// 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 använda Iterator-gränssnittet för att gå över vilken struktur som helst i Collection Framework. Eftersom Iterators arbetar med en typ av data använder vi Entry< ? ? >för att lösa de två separata typerna till ett kompatibelt format. Med hjälp av metoden next() skriver vi ut elementen 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

Om flera trådar får åtkomst till en identitetshashkarta samtidigt och minst en av trådarna ändrar kartan strukturellt måste den synkroniseras externt. (En strukturell modifiering är vilken operation som helst som lägger till eller tar bort en eller flera mappningar; att bara ändra värdet som är associerat med en nyckel som en instans redan innehåller är inte en strukturell modifiering.) Detta åstadkoms vanligtvis genom att synkronisera på något objekt som naturligt kapslar in kartan. Om inget sådant objekt existerar ska kartan "lindas" med hjälp av Collections.synchronizedMap metod. Detta görs bäst vid skapandet för att förhindra osynkroniserad åtkomst till kartan av misstag. 

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

Metoder för IdentityHashMap

K– Typen av nycklar i kartan.V– Typen av värden som mappas i kartan.

Metoder deklarerade i klassen java.util.AbstractMap

Metoder som deklareras i gränssnittet java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap använder likhetsoperatorn '==' för att jämföra nycklar och värden medan HashMap använder likametoden för att jämföra nycklar och värden inuti Map.
• Eftersom IdentityHashMap inte använder equals() är det jämförelsevis snabbare än HashMap för ett objekt med dyrt equals().
• IdentityHashMap kräver inte att nycklar är oföränderliga eftersom den inte är beroende av equals().

Nedanstående program illustrerar skillnaden mellan IdentityHashMap och 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 är en klass i Java som implementerar Map-gränssnittet och använder referenslikhet för att jämföra nycklar. Det liknar en vanlig HashMap men den använder operatorn == för att jämföra nycklar istället för metoden equals(). Detta innebär att två nycklar med samma innehåll men olika objektreferenser kommer att behandlas som distinkta nycklar i en IdentityHashMap.

Här är ett exempel på hur du använder 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 det här exemplet skapar vi en IdentityHashMap som mappar strängnycklar till heltalsvärden. Vi lägger till två nyckel-värdepar till kartan med två olika String-objekt som har samma innehåll. Vi hämtar sedan värden från kartan med samma och olika String-objekt. Vi finner att vi kan hämta värden från kartan med de två olika nycklarna som har samma innehåll men vi kan inte hämta ett värde med ett String-objekt som har samma innehåll men som är en annan objektreferens.

Observera att IdentityHashMap har ett lite annorlunda beteende än en vanlig HashMap och är i allmänhet bara användbar i vissa situationer där referenslikhet är viktigt. I de flesta fall är en vanlig HashMap tillräcklig och mer lämplig.

turbo c++ ladda ner