The IdentityHashMap unelte Hartă folosind interfata Hashtable utilizarea egalității de referință în locul egalității obiectelor atunci când se compară cheile (și valorile). Această clasă nu este o implementare Map cu scop general. În timp ce această clasă implementează interfața Map, încalcă în mod intenționat contractul general Map care impune utilizarea metodei equals() atunci când se compară obiecte. Această clasă este utilizată atunci când utilizatorul cere ca obiectele să fie comparate prin referință. Ii apartine java.util pachet.

Caracteristicile IdentityHashMap

• Urmează egalitatea de referință în loc să folosească metoda equals(), folosește operatorul ==.
• Nu este sincronizat și trebuie să fie sincronizat extern.
• Iteratoarele sunt aruncări rapide ConcurrentModificationException într-o încercare de modificare în timpul iterării.
• Această clasă oferă performanță în timp constant pentru operațiunile de bază (obținere și introducere) presupunând că funcția hash de identitate a sistemului (System.identityHashCode(Object)) dispersează elementele în mod corespunzător printre găleți. IdentityHashMap nu folosește metoda hashCode(), ci folosește metoda System.identityHashCode(). Aceasta este o diferență semnificativă, deoarece acum puteți utiliza obiecte mutabile ca cheie în Map al căror cod hash este probabil să se schimbe atunci când maparea este stocată în IdentityHashMap.

Declaraţie:

clasă publică IdentityHashMapextinde AbstractMapimplementează HartaSerializabil Clonabil 
 

Aici K este tipul de obiect cheie și V este valoarea Object type.

În Java, IdentityHashMap este o clasă care implementează interfața Map. Este similar cu clasa HashMap, principala diferență fiind că IdentityHashMap folosește egalitatea referințelor în loc de egalitatea obiectelor atunci când compară cheile.

În timp ce HashMap folosește metoda equals() pentru a compara cheile, IdentityHashMap folosește operatorul == pentru a compara cheile. Aceasta înseamnă că într-un IdentityHashMap două chei sunt considerate egale dacă și numai dacă sunt același obiect, mai degrabă decât să fie egale în ceea ce privește conținutul lor.

imaginea centrală în css

Iată un exemplu despre cum ați putea folosi un IdentityHashMap în 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  } } 

ieșire;

2 

1

Clasa IdentityHashMap în Java este o implementare bazată pe tabel hash a interfeței Map care utilizează egalitatea referințelor în loc de egalitatea obiectelor atunci când compară cheile (și valorile).

Avantajele utilizării IdentityHashMap față de HashMap:

1. Căutări mai rapide: Deoarece IdentityHashMap folosește egalitatea de referință pentru comparație, este mai rapidă pentru căutări în comparație cu HashMap care utilizează egalitatea obiectelor.
2. Util pentru compararea instanțelor obiectului: IdentityHashMap este utilă în situațiile în care doriți să comparați instanțele obiectului, mai degrabă decât valorile obiectului.

Dezavantajele utilizării IdentityHashMap:

1. Utilizează mai multă memorie: IdentityHashMap utilizează mai multă memorie în comparație cu HashMap, deoarece trebuie să stocheze referința la obiect.
2. Nu este potrivit pentru toate cazurile de utilizare: IdentityHashMap nu este potrivit pentru toate cazurile de utilizare și trebuie utilizat cu precauție, deoarece poate duce la un comportament neașteptat în anumite situații.

Ierarhia IdentityHashMap

Se implementează Serializabil Clonabil Hartă interfețe și se extinde AbstractHarta clasă.

Exemplu:

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

Constructorii IdentityHashMap

Putem crea o instanță de IdentityHashMap în două moduri:

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

1. IdentityHashMap():  Construiește o nouă hartă hash de identitate goală cu o dimensiune maximă preconizată implicită. 

IdentityHashMapel = noua IdentityHashMap();

2. IdentityHashMap(int expectedMaxSize):  Construiește o nouă hartă goală cu dimensiunea maximă așteptată specificată. 

IdentityHashMapihm = new IdentityHashMap (int waitedMaxSize);

3. IdentityHashMap(Harta m):  Construiește o nouă hartă hash de identitate care conține mapările cheie-valoare din harta specificată.

IdentityHashMapihm = nou IdentityHashMap(Harta m);

matrice de octeți java în șir

Operații de bază pe IdentityHashMap

1. Adăugarea de elemente

Pentru a insera sau adăuga mapare într-un IdentityHashMap avem pune() şi pune tot() metode. put() poate insera o anumită cheie și valoarea pe care o mapează într-o anumită hartă. Dacă o cheie existentă este transmisă, atunci valoarea anterioară este înlocuită cu noua valoare. putAll() copiază toate elementele, adică mapările de pe o hartă în alta. 

subliniați textul cu css

// 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. Îndepărtarea elementelor
Pentru a elimina mapările pe care le folosim elimina() o metodă încorporată a clasei IdentityHashMap și este folosită pentru a elimina maparea oricărei chei particulare de pe hartă.

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

Putem accesa elementele unui IdentityHashMap folosind obţine() metoda, exemplul acesteia este dat mai jos.

// 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. Traversarea
Putem folosi interfața Iterator pentru a parcurge orice structură a cadrului de colectare. Deoarece iteratorii lucrează cu un singur tip de date, folosim Entry< ? ? >pentru a rezolva cele două tipuri separate într-un format compatibil. Apoi folosind metoda next() imprimăm elementele 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 

Sincronizat IdentityHashMap

Dacă mai multe fire de execuție accesează o hartă hash de identitate simultan și cel puțin unul dintre fire de execuție modifică structura structural, aceasta trebuie sincronizată extern. (O modificare structurală este orice operațiune care adaugă sau șterge una sau mai multe mapări; simpla modificare a valorii asociate cu o cheie pe care o instanță o conține deja nu este o modificare structurală.) Aceasta este de obicei realizată prin sincronizarea pe un obiect care încapsulează în mod natural harta. Dacă nu există un astfel de obiect, harta ar trebui să fie „înfășurată” folosind Colecții.Hartă sincronizată metodă. Cel mai bine se face acest lucru în momentul creării pentru a preveni accesul accidental nesincronizat la hartă. 

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

Metode de IdentityHashMap

K– Tipul cheilor din hartă.V– Tipul de valori mapate în hartă.

Metode declarate în clasa java.util.AbstractMap

Metode declarate în interfața java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap folosește operatorul de egalitate „==” pentru a compara cheile și valorile, în timp ce HashMap utilizează metoda equals pentru a compara cheile și valorile din interiorul Map.
• Deoarece IdentityHashMap nu folosește equals(), este relativ mai rapid decât HashMap pentru un obiect cu equals() scump.
• IdentityHashMap nu necesită chei pentru a fi imuabile, deoarece nu se bazează pe equals().

Programul de mai jos ilustrează diferența dintre implementarea IdentityHashMap și 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 este o clasă în Java care implementează interfața Map și utilizează egalitatea de referință pentru a compara cheile. Este similar cu un HashMap obișnuit, dar folosește operatorul == pentru a compara cheile în loc de metoda equals(). Aceasta înseamnă că două chei cu același conținut, dar referințe diferite la obiect vor fi tratate ca chei distincte într-un IdentityHashMap.

Iată un exemplu de utilizare a IdentityHashMap în 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 

În acest exemplu, creăm un IdentityHashMap care mapează cheile String la valori întregi. Adăugăm două perechi cheie-valoare pe hartă folosind două obiecte String diferite care au același conținut. Apoi recuperăm valorile de pe hartă folosind aceleași și diferite obiecte String. Constatăm că putem prelua valori de pe hartă utilizând cele două chei diferite care au același conținut, dar nu putem prelua o valoare folosind un obiect String care are același conținut, dar este o referință diferită de obiect.

Rețineți că IdentityHashMap are un comportament ușor diferit față de un HashMap obișnuit și este, în general, util doar în anumite situații în care egalitatea de referință este importantă. În cele mai multe cazuri, un HashMap obișnuit este suficient și mai adecvat.

python scrie json în fișier