TŘÍDA IDENTITYHASHMAP V JAVĚ

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 IdentityHashMap rozšiřuje AbstractMap implementuje Mapu Serializovatelný 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.

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

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

výstup;

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:

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.
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:

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

IdentityHashMap v Javě

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

Příklad:

Java

    // 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  ());          }   }

Výstup

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í.

IdentityHashMap him = nová IdentityHashMap ();

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

IdentityHashMap ihm = 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ě.

IdentityHashMap ihm = 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

    // 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  );      }   }

Výstup

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

    // 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  );         }      }

Výstup

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

    // 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  ());         }   }

Výstup

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

    // 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  ());      }      }   }

Výstup

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

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ě.

METODA	POPIS
jasný()	Odstraní všechna mapování z této mapy.
klon()	Vrátí mělkou kopii této mapy hash identity: samotné klíče a hodnoty nejsou klonovány.
obsahuje klíč? (klíč objektu)	Testuje, zda je zadaný odkaz na objekt klíčem v této mapě hash identity.
obsahujeValue?(hodnota objektu)	Testuje, zda je zadaný odkaz na objekt hodnotou v této mapě hash identity.
entrySet()	Vrací a Soubor pohled na mapování obsažené v této mapě.
rovná se? (Objekt o)	Porovná zadaný objekt s touto mapou pro dosažení rovnosti.
získat? (klíč objektu)	Vrátí hodnotu, na kterou je zadaný klíč mapován, nebo hodnotu null, pokud tato mapa neobsahuje žádné mapování pro klíč.
hashCode()	Vrátí hodnotu hash kódu pro tuto mapu.
isEmpty()	Vrátí hodnotu true, pokud tato mapa hash identity neobsahuje žádná mapování párů klíč–hodnota.
keySet()	Vrátí zobrazení sady klíčů obsažených v této mapě založené na identitě.
dát? (hodnota K klíče V)	Přidruží zadanou hodnotu k zadanému klíči v této mapě hash identity.
putAll? (Mapa m)	Zkopíruje všechna mapování ze zadané mapy do této mapy.
odstranit? (klíč objektu)	Odstraní mapování pro tento klíč z této mapy, pokud existuje.
velikost()	Vrátí počet mapování párů klíč–hodnota v této mapě hash identity.
hodnoty()	Vrátí pohled kolekce hodnot obsažených v této mapě.

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

METODA	POPIS
toString()	Vrátí řetězcovou reprezentaci této mapy.

Metody deklarované v rozhraní java.util.Map

METODA	POPIS
vypočítat? (Klávesa BiFunction přemapování)	Pokusí se vypočítat mapování pro zadaný klíč a jeho aktuální mapovanou hodnotu (nebo null, pokud neexistuje žádné aktuální mapování).
computeIfAbsent? (Funkce klávesy K mapování)	Pokud zadaný klíč ještě není přidružen k hodnotě (nebo je mapován na hodnotu null), pokusí se vypočítat svou hodnotu pomocí dané mapovací funkce a vloží ji do této mapy, pokud není null.
computeIfPresent? (Klíč BiFunction přemapování)	Pokud je přítomna hodnota pro zadaný klíč a pokusí se vypočítat nové mapování zadanému klíčem a jeho aktuální mapovanou hodnotou.
pro každého? (BiConsumer akce)	Provede danou akci pro každý záznam v této mapě, dokud nebudou zpracovány všechny záznamy nebo akce vyvolá výjimku.
getOrDefault? (klíč objektu V defaultValue)	Vrátí hodnotu, na kterou je zadaný klíč namapován, nebo defaultValue, pokud tato mapa neobsahuje žádné mapování pro klíč.
sloučit? (K klíč V hodnota BiFunction přemapování)	Pokud zadaný klíč ještě není přidružen k hodnotě nebo je přidružen k hodnotě null, přidruží jej k dané jiné hodnotě.
putIfAbsent? (K klíčová hodnota V)	Pokud zadaný klíč ještě není přidružen k hodnotě (nebo je namapován na hodnotu null), přiřadí jej k dané hodnotě a vrátí hodnotu null, jinak vrátí aktuální hodnotu.
odstranit? (klíč objektu Hodnota objektu)	Odebere položku pro zadaný klíč pouze v případě, že je aktuálně namapován na zadanou hodnotu.
nahradit? (hodnota K klíče V)	Nahradí položku pro zadaný klíč pouze v případě, že je aktuálně namapován na nějakou hodnotu.
nahradit? (K klíč V stará hodnota V nová hodnota)	Nahradí položku pro zadaný klíč, pouze pokud je aktuálně namapován na zadanou hodnotu.
nahradit vše? (BiFunction funkce)	Nahradí hodnotu každé položky výsledkem vyvolání dané funkce na této položce, dokud nebudou zpracovány všechny položky nebo funkce vyvolá výjimku.

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

    // 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  ());          }   }

Výstup

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ě:

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

Výstup

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.

Vytvořit kvíz