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 IdentityHashMapestende AbstractMapimplementa MapSerializzabile, 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.

estrazione dei dati

Ecco un esempio di come potresti utilizzare IdentityHashMap in 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;

2 

1

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:

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

1. Utilizza più memoria: IdentityHashMap utilizza più memoria rispetto a HashMap poiché deve memorizzare il riferimento all'oggetto.
2. 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

selezione di più tabelle sql

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

Esempio:

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

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. 

IdentityHashMaplui = nuova IdentityHashMap();

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

IdentityHashMapihm = new IdentityHashMap(int attesoMaxSize);

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

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

len dell'array in Java

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

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

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.

Metodi dichiarati nella classe java.util.AbstractMap

Metodi dichiarati nell'interfaccia java.util.Map

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

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 

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.

python scrive json su file