CLASSE IDENTITYHASHMAP IN JAVA

IL IdentityHashMap implementa Mappa interfaccia utilizzando Tabella hash utilizzando l'uguaglianza dei riferimenti al posto dell'uguaglianza degli oggetti quando si confrontano chiavi (e valori). Questa classe non è un'implementazione Map generica. Sebbene questa classe implementi l'interfaccia Map, viola intenzionalmente il contratto generale di Map che impone l'uso del metodo equals() durante il confronto degli oggetti. Questa classe viene utilizzata quando l'utente richiede il confronto degli oggetti tramite riferimento. Appartiene a java.util pacchetto.

Caratteristiche di IdentityHashMap

Segue l'uguaglianza dei riferimenti invece di utilizzare il metodo equals() utilizza l'operatore ==.
Non è sincronizzato e deve essere sincronizzato esternamente.
Gli iteratori sono di tipo fail-fast ConcurrentModificationException nel tentativo di modificare durante l'iterazione.
Questa classe fornisce prestazioni costanti per le operazioni di base (get e put) presupponendo che la funzione hash dell'identità del sistema (System.identityHashCode(Object)) disperda correttamente gli elementi tra i bucket. IdentityHashMap non utilizza il metodo hashCode() ma utilizza il metodo System.identityHashCode(). Questa è una differenza significativa perché ora puoi utilizzare oggetti mutabili come chiave in Map il cui codice hash probabilmente cambierà quando la mappatura viene archiviata all'interno di IdentityHashMap.

Dichiarazione:

classe pubblica IdentityHashMap estende AbstractMap implementa Map Serializzabile, clonabile

Qui K è il tipo di oggetto chiave e V è il valore Tipo oggetto.

In Java IdentityHashMap è una classe che implementa l'interfaccia Map. È simile alla classe HashMap con la differenza principale che IdentityHashMap utilizza l'uguaglianza dei riferimenti invece dell'uguaglianza degli oggetti quando si confrontano le chiavi.

Mentre HashMap utilizza il metodo equals() per confrontare le chiavi, IdentityHashMap utilizza l'operatore == per confrontare le chiavi. Ciò significa che in una IdentityHashMap due chiavi sono considerate uguali se e solo se sono lo stesso oggetto anziché essere uguali in termini di contenuto.

Ecco un esempio di come potresti utilizzare IdentityHashMap in Java:

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

produzione;

La classe IdentityHashMap in Java è un'implementazione basata su tabella hash dell'interfaccia Map che utilizza l'uguaglianza dei riferimenti al posto dell'uguaglianza degli oggetti quando si confrontano chiavi (e valori).

Vantaggi dell'utilizzo di IdentityHashMap rispetto a HashMap:

Ricerche più veloci: poiché IdentityHashMap utilizza l'uguaglianza dei riferimenti per il confronto, le ricerche sono più veloci rispetto a HashMap che utilizza l'uguaglianza degli oggetti.
Utile per confrontare istanze di oggetti: IdentityHashMap è utile in situazioni in cui si desidera confrontare istanze di oggetti anziché valori di oggetti.

Svantaggi dell'utilizzo di IdentityHashMap:

Utilizza più memoria: IdentityHashMap utilizza più memoria rispetto a HashMap poiché deve memorizzare il riferimento all'oggetto.
Non adatto a tutti i casi d'uso: IdentityHashMap non è adatto a tutti i casi d'uso e deve essere utilizzato con cautela poiché può portare a comportamenti imprevisti in determinate situazioni.

La gerarchia di IdentityHashMap

IdentityHashMap in Java

Implementa Serializzabile Clonabile Mappa si interfaccia e si estende Mappa astratta classe.

Esempio:

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

Produzione

Size of IdentityHashMap--2

Costruttori di IdentityHashMap

Possiamo creare un'istanza di IdentityHashMap in due modi:

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

1. IdentityHashMap(): Costruisce una nuova mappa hash di identità vuota con una dimensione massima prevista predefinita.

IdentityHashMap lui = nuova IdentityHashMap ();

2. IdentityHashMap(int previstoMaxSize): Costruisce una nuova mappa vuota con la dimensione massima prevista specificata.

IdentityHashMap ihm = new IdentityHashMap(int attesoMaxSize);

3. IdentityHashMap (Mappa m): Costruisce una nuova mappa hash di identità contenente le mappature dei valori-chiave nella mappa specificata.

IdentityHashMap ihm = new IdentityHashMap(Mappa m);

Operazioni di base su IdentityHashMap

1. Aggiunta di elementi

Per inserire o aggiungere la mappatura in un IdentityHashMap abbiamo Mettere() E mettiTutto() metodi. put() può inserire una chiave specifica e il valore che sta mappando in una particolare mappa. Se viene passata una chiave esistente, il valore precedente viene sostituito dal nuovo valore. putAll() copia tutti gli elementi, ovvero le mappature da una mappa all'altra.

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

Produzione

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. Rimozione di elementi
Per rimuovere le mappature utilizziamo rimuovere() un metodo integrato della classe IdentityHashMap e viene utilizzato per rimuovere la mappatura di qualsiasi chiave particolare dalla mappa.

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

Produzione

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. Accesso agli elementi

Possiamo accedere agli elementi di una IdentityHashMap utilizzando il file Ottenere() metodo, l'esempio di questo è fornito di seguito.

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

Produzione

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. Attraversamento
Possiamo utilizzare l'interfaccia Iterator per attraversare qualsiasi struttura del Collection Framework. Poiché gli Iteratori lavorano con un tipo di dati, utilizziamo Entry < ? ? >per risolvere i due tipi separati in un formato compatibile. Quindi utilizzando il metodo next() stampiamo gli elementi di 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  ());      }      }   }

Produzione

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

IdentityHashMap sincronizzato

Se più thread accedono contemporaneamente a una mappa hash di identità e almeno uno dei thread modifica strutturalmente la mappa, deve essere sincronizzata esternamente. (Una modifica strutturale è qualsiasi operazione che aggiunge o elimina una o più mappature; la semplice modifica del valore associato a una chiave che un'istanza già contiene non è una modifica strutturale.) Ciò viene in genere ottenuto mediante la sincronizzazione su qualche oggetto che incapsula naturalmente la mappa. Se non esiste alcun oggetto di questo tipo, la mappa dovrebbe essere "avvolta" utilizzando il comando Collezioni.synchronizedMap metodo. È meglio farlo al momento della creazione per impedire l'accesso accidentale e non sincronizzato alla mappa.

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

Metodi di IdentityHashMap

K – Il tipo delle chiavi nella mappa. V – Il tipo di valori mappati nella mappa.

METODO	DESCRIZIONE
chiaro()	Rimuove tutte le mappature da questa mappa.
clone()	Restituisce una copia superficiale di questa mappa hash di identità: le chiavi e i valori stessi non vengono clonati.
contieneChiave?(Chiave oggetto)	Verifica se il riferimento all'oggetto specificato è una chiave in questa mappa hash di identità.
contieneValore?(Valore oggetto)	Verifica se il riferimento all'oggetto specificato è un valore in questa mappa hash di identità.
set di voci()	Restituisce a Impostato visualizzazione delle mappature contenute in questa mappa.
è uguale a?(Oggetto o)	Confronta l'oggetto specificato con questa mappa per verificarne l'uguaglianza.
ottenere?(tasto oggetto)	Restituisce il valore a cui è mappata la chiave specificata oppure null se questa mappa non contiene alcuna mappatura per la chiave.
codicehash()	Restituisce il valore del codice hash per questa mappa.
èVuoto()	Restituisce true se questa mappa hash di identità non contiene mappature di valori-chiave.
keySet()	Restituisce una visualizzazione dell'insieme basata sull'identità delle chiavi contenute in questa mappa.
mettere?(Valore V chiave K)	Associa il valore specificato alla chiave specificata in questa mappa hash di identità.
putAll?(Mappa M)	Copia tutte le mappature dalla mappa specificata a questa mappa.
rimuovere?(Chiave oggetto)	Rimuove la mappatura per questa chiave da questa mappa, se presente.
misurare()	Restituisce il numero di mappature di valori-chiave in questa mappa hash di identità.
valori()	Restituisce una vista Raccolta dei valori contenuti in questa mappa.

Metodi dichiarati nella classe java.util.AbstractMap

METODO	DESCRIZIONE
aString()	Restituisce una rappresentazione di stringa di questa mappa.

Metodi dichiarati nell'interfaccia java.util.Map

METODO	DESCRIZIONE
calcolare?(Tasto K BiFunzione funzione rimappatura)	Tenta di calcolare una mappatura per la chiave specificata e il relativo valore mappato corrente (o null se non è presente alcuna mappatura corrente).
computeIfAbsent?(Tasto K Funzione funzione di mappatura)	Se la chiave specificata non è già associata a un valore (o è mappata su null) tenta di calcolarne il valore utilizzando la funzione di mappatura specificata e la inserisce in questa mappa a meno che non sia null.
computeIfPresent?(Tasto K BiFunction funzione rimappatura)	Se il valore per la chiave specificata è presente e un valore diverso da null tenta di calcolare una nuova mappatura in base alla chiave e al relativo valore mappato corrente.
perEach?(BiConsumer azione)	Esegue l'azione specificata per ogni voce in questa mappa finché tutte le voci non vengono elaborate o l'azione genera un'eccezione.
getOrDefault?(Chiave oggetto V defaultValue)	Restituisce il valore a cui è mappata la chiave specificata o defaultValue se questa mappa non contiene alcuna mappatura per la chiave.
unire?(Tasto K valore V BiFunzione funzione rimappatura)	Se la chiave specificata non è già associata a un valore o è associata a null, la associa al valore non null specificato.
putIfAbsent?(Valore V chiave K)	Se la chiave specificata non è già associata a un valore (o è mappata su null) la associa al valore specificato e restituisce null altrimenti restituisce il valore corrente.
rimuovere?(Chiave oggetto Valore oggetto)	Rimuove la voce per la chiave specificata solo se è attualmente mappata al valore specificato.
sostituire? (valore V chiave K)	Sostituisce la voce per la chiave specificata solo se è attualmente mappata su un valore.
sostituire?(Chiave K V vecchioValore V nuovoValore)	Sostituisce la voce per la chiave specificata solo se attualmente mappata al valore specificato.
sostituire tutto?(BiFunzione funzione)	Sostituisce il valore di ciascuna voce con il risultato dell'invocazione della funzione specificata su quella voce fino a quando tutte le voci non sono state elaborate o la funzione genera un'eccezione.

IdentityHashMap vs HashMap

IdentityHashMap utilizza l'operatore di uguaglianza '==' per confrontare chiavi e valori mentre HashMap utilizza il metodo equals per confrontare chiavi e valori all'interno di Map.
Poiché IdentityHashMap non utilizza equals() è relativamente più veloce di HashMap per un oggetto con equals() costoso.
IdentityHashMap non richiede che le chiavi siano immutabili poiché non si basa su equals().

Il programma seguente illustra la differenza tra l'implementazione di IdentityHashMap e 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  ());          }   }

Produzione

Size of HashMap is : 1 Size of IdentityHashMap is : 2

IdentityHashMap è una classe in Java che implementa l'interfaccia Map e utilizza l'uguaglianza dei riferimenti per confrontare le chiavi. È simile a una normale HashMap ma utilizza l'operatore == per confrontare le chiavi invece del metodo equals(). Ciò significa che due chiavi con lo stesso contenuto ma riferimenti a oggetti diversi verranno trattate come chiavi distinte in una IdentityHashMap.

Ecco un esempio di come utilizzare IdentityHashMap in Java:

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

Produzione

1 2 null

In questo esempio creiamo un IdentityHashMap che associa le chiavi String a valori Integer. Aggiungiamo due coppie chiave-valore alla mappa utilizzando due diversi oggetti String che hanno lo stesso contenuto. Quindi recuperiamo i valori dalla mappa utilizzando gli stessi oggetti String e diversi. Scopriamo che possiamo recuperare valori dalla mappa utilizzando due chiavi diverse che hanno lo stesso contenuto ma non possiamo recuperare un valore utilizzando un oggetto String che ha lo stesso contenuto ma è un riferimento a un oggetto diverso.

Tieni presente che IdentityHashMap ha un comportamento leggermente diverso rispetto a una HashMap normale ed è generalmente utile solo in determinate situazioni in cui l'uguaglianza dei riferimenti è importante. Nella maggior parte dei casi una HashMap normale è sufficiente e più appropriata.

Crea quiz