The IdentityHashMap nářadí Mapa pomocí rozhraní Hashtable použití referenční rovnosti místo objektové rovnosti při porovnávání klíčů (a hodnot). Tato třída není implementací mapy pro obecné účely. I když tato třída implementuje rozhraní Map, záměrně porušuje obecnou smlouvu Map, která nařizuje použití metody equals() při porovnávání objektů. Tato třída se používá, když uživatel požaduje porovnání objektů pomocí odkazu. Patří k java.util balík.

Vlastnosti IdentityHashMap

• Dodržuje referenční rovnost namísto použití metody equals() používá operátor ==.
• Není synchronizován a musí být synchronizován externě.
• Iterátory jsou rychlé házení ConcurrentModificationException ve snaze upravit při iteraci.
• Tato třída poskytuje výkon v konstantním čase pro základní operace (získání a vložení) za předpokladu, že hashovací funkce systémové identity (System.identityHashCode(Object)) správně rozmístí prvky mezi segmenty. IdentityHashMap nepoužívá metodu hashCode() místo toho používá metodu System.identityHashCode(). To je významný rozdíl, protože nyní můžete jako klíč v Map použít měnitelné objekty, jejichž hash kód se pravděpodobně změní, když je mapování uloženo v IdentityHashMap.

Prohlášení:

veřejná třída IdentityHashMaprozšiřuje AbstractMapimplementuje MapuSerializovatelný Klonovatelný 
 

Zde K je klíč Typ objektu a PROTI je hodnota Typ objektu.

V Javě je IdentityHashMap třída, která implementuje rozhraní Map. Je podobná třídě HashMap s hlavním rozdílem v tom, že IdentityHashMap používá při porovnávání klíčů referenční rovnost místo rovnosti objektů.

Zatímco HashMap používá k porovnání klíčů metodu equals(), IdentityHashMap používá k porovnání klíčů operátor ==. To znamená, že v IdentityHashMap jsou dva klíče považovány za rovnocenné tehdy a pouze tehdy, pokud jsou stejným objektem, spíše než aby byly stejné z hlediska jejich obsahu.

plsql

Zde je příklad toho, jak můžete použít IdentityHashMap v Javě:

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

výstup;

2 

1

Třída IdentityHashMap v Javě je implementace rozhraní Map založená na hashovacích tabulkách, která při porovnávání klíčů (a hodnot) používá referenční rovnost místo objektové rovnosti.

Výhody použití IdentityHashMap oproti HashMap:

1. Rychlejší vyhledávání: Vzhledem k tomu, že IdentityHashMap používá pro srovnání referenční rovnost, je rychlejší pro vyhledávání ve srovnání s HashMap, která používá objektovou rovnost.
2. Užitečné pro porovnávání instancí objektů: IdentityHashMap je užitečná v situacích, kdy chcete porovnávat instance objektů spíše než hodnoty objektů.

Nevýhody použití IdentityHashMap:

1. Využívá více paměti: IdentityHashMap využívá více paměti ve srovnání s HashMap, protože potřebuje uložit odkaz na objekt.
2. Není vhodný pro všechny případy použití: IdentityHashMap není vhodný pro všechny případy použití a měl by být používán s opatrností, protože může v určitých situacích vést k neočekávanému chování.

Hierarchie IdentityHashMap

Realizuje Serializovatelné Klonovatelné Mapa rozhraní a rozšiřuje Abstraktní mapa třída.

Příklad:

// 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éři IdentityHashMap

Můžeme vytvořit instanci IdentityHashMap dvěma způsoby:

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

1. IdentityHashMap():  Vytvoří novou prázdnou mapu hash identity s výchozí očekávanou maximální velikostí. 

IdentityHashMaphim = nová IdentityHashMap();

2. IdentityHashMap (int očekáváníMaxSize):  Vytvoří novou prázdnou mapu se zadanou očekávanou maximální velikostí. 

linuxové chybové kódy

IdentityHashMapihm = new IdentityHashMap(int očekáváníMaxSize);

3. IdentityHashMap (mapa m):  Vytvoří novou mapu hash identity obsahující mapování párů klíč–hodnota v zadané mapě.

IdentityHashMapihm = new IdentityHashMap(Map m);

Základní operace na IdentityHashMap

1. Přidávání prvků

Pro vložení nebo přidání mapování do IdentityHashMap máme dát() a putAll() metody. put() může vložit konkrétní klíč a hodnotu, kterou mapuje, do konkrétní mapy. Pokud je předán existující klíč, bude předchozí hodnota nahrazena novou hodnotou. putAll() zkopíruje všechny prvky, tj. mapování z jedné mapy do druhé. 

// 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. Odstranění prvků
K odstranění mapování, které používáme odstranit() vestavěná metoda třídy IdentityHashMap a používá se k odstranění mapování jakéhokoli konkrétního klíče z mapy.

// 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. Přístup k prvkům

K prvkům IdentityHashMap můžeme přistupovat pomocí získat() způsob, příklad tohoto je uveden níže.

// 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. Přecházení
Rozhraní Iterator můžeme použít k procházení libovolnou strukturou Collection Framework. Protože iterátory pracují s jedním typem dat, používáme Entry< ? ? >přeložit dva samostatné typy do kompatibilního formátu. Poté pomocí metody next() vytiskneme prvky 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 

Synchronizovaná IdentityHashMap

algoritmus řazení haldy

Pokud k mapě hash identity přistupuje více vláken současně a alespoň jedno z vláken strukturálně modifikuje mapu, musí být synchronizována externě. (Strukturální modifikace je jakákoli operace, která přidá nebo odstraní jedno nebo více mapování; pouhá změna hodnoty spojené s klíčem, který instance již obsahuje, není strukturální modifikace.) Toho se obvykle dosáhne synchronizací na nějakém objektu, který přirozeně zapouzdřuje mapu. Pokud žádný takový objekt neexistuje, mapa by měla být „zabalena“ pomocí Collections.synchronizedMap metoda. To se nejlépe provádí v době vytvoření, aby se zabránilo náhodnému nesynchronizovanému přístupu k mapě. 

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

Metody IdentityHashMap

K– Typ kláves na mapě.PROTI– Typ hodnot mapovaných v mapě.

Metody deklarované ve třídě java.util.AbstractMap

Metody deklarované v rozhraní java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap používá operátor rovnosti '==' pro porovnání klíčů a hodnot, zatímco HashMap používá metodu rovná se pro porovnání klíčů a hodnot uvnitř Map.
• Protože IdentityHashMap nepoužívá equals(), je pro objekt s drahým equals() srovnatelně rychlejší než HashMap.
• IdentityHashMap nevyžaduje, aby klíče byly neměnné, protože se nespoléhá na equals().

Níže uvedený program ilustruje rozdíl mezi implementací IdentityHashMap a HashMap.

// 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 je třída v Javě, která implementuje rozhraní Map a používá referenční rovnost k porovnání klíčů. Je podobná běžné HashMap, ale k porovnání klíčů používá operátor == namísto metody equals(). To znamená, že dva klíče se stejným obsahem, ale různými odkazy na objekty budou v IdentityHashMap považovány za odlišné klíče.

Zde je příklad, jak používat IdentityHashMap v Javě:

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 

V tomto příkladu vytvoříme IdentityHashMap, která mapuje klíče String na celočíselné hodnoty. Do mapy přidáme dva páry klíč–hodnota pomocí dvou různých objektů String, které mají stejný obsah. Hodnoty pak načteme z mapy pomocí stejných a různých objektů String. Zjistili jsme, že můžeme načíst hodnoty z mapy pomocí dvou různých klíčů, které mají stejný obsah, ale nemůžeme načíst hodnotu pomocí objektu String, který má stejný obsah, ale je odkazem na jiný objekt.

Všimněte si, že IdentityHashMap má mírně odlišné chování než běžná HashMap a je obecně užitečný pouze v určitých situacích, kdy je důležitá rovnost referenčních údajů. Ve většině případů stačí a vhodnější běžná HashMap.

java string.format