The IdentityHashMap oruđa Karta korištenje sučelja Raspršena tablica korištenje referentne jednakosti umjesto objektne jednakosti pri usporedbi ključeva (i vrijednosti). Ova klasa nije implementacija Mape opće namjene. Iako ova klasa implementira Map sučelje, ona namjerno krši Mapov opći ugovor koji nalaže upotrebu equals() metode pri usporedbi objekata. Ova klasa se koristi kada korisnik zahtijeva da se objekti uspoređuju putem reference. Pripada java.util paket.

Značajke IdentityHashMapa

• Slijedi referentnu jednakost umjesto korištenja metode equals(), koristi == operator.
• Nije sinkroniziran i mora se eksterno sinkronizirati.
• Iteratori su fail-fast throw ConcurrentModificationException u pokušaju izmjene tijekom ponavljanja.
• Ova klasa pruža performanse u konstantnom vremenu za osnovne operacije (dobi i stavi) pod pretpostavkom da hash funkcija identiteta sustava (System.identityHashCode(Object)) ispravno raspoređuje elemente među spremnicima. IdentityHashMap ne koristi metodu hashCode(), već koristi metodu System.identityHashCode(). Ovo je značajna razlika jer sada možete koristiti promjenjive objekte kao ključeve u Mapi čiji će se hash kod vjerojatno promijeniti kada se mapiranje pohrani unutar IdentityHashMap.

deklaracija:

javna klasa IdentityHashMapproširuje AbstractMapimplementira MapSerializable Cloneable 
 

Ovdje K je ključna vrsta objekta i V je vrijednost Vrsta objekta.

U Javi IdentityHashMap je klasa koja implementira sučelje karte. Sličan je klasi HashMap s glavnom razlikom što IdentityHashMap koristi referentnu jednakost umjesto objektne jednakosti pri usporedbi ključeva.

Dok HashMap koristi equals() metodu za usporedbu ključeva, IdentityHashMap koristi == operator za usporedbu ključeva. To znači da se u IdentityHashMap dva ključa smatraju jednakima ako i samo ako su isti objekt, a ne jednaki u smislu njihovog sadržaja.

središnja slika u css-u

Evo primjera kako možete koristiti IdentityHashMap u Javi:

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

izlaz;

2 

1

Klasa IdentityHashMap u Javi je implementacija sučelja karte koja se temelji na tablici raspršivanja koja koristi referentnu jednakost umjesto objektne jednakosti pri usporedbi ključeva (i vrijednosti).

Prednosti korištenja IdentityHashMap u odnosu na HashMap:

1. Brža traženja: Budući da IdentityHashMap koristi referentnu jednakost za usporedbu, brže je traženje u usporedbi s HashMapom koji koristi jednakost objekata.
2. Korisno za usporedbu instanci objekta: IdentityHashMap je koristan u situacijama kada želite usporediti instance objekta, a ne vrijednosti objekta.

Nedostaci korištenja IdentityHashMapa:

1. Koristi više memorije: IdentityHashMap koristi više memorije u usporedbi s HashMapom jer treba pohraniti referencu na objekt.
2. Nije prikladan za sve slučajeve upotrebe: IdentityHashMap nije prikladan za sve slučajeve upotrebe i treba ga koristiti s oprezom jer može dovesti do neočekivanog ponašanja u određenim situacijama.

Hijerarhija IdentityHashMap

Provodi Serializable Može se klonirati Karta sučelja i proširenja SažetakMap razreda.

Primjer:

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

Konstruktori IdentityHashMapa

Možemo stvoriti primjerak IdentityHashMap na dva načina:

java boje

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

1. IdentityHashMap():  Konstruira novu praznu hash mapu identiteta sa zadanom očekivanom maksimalnom veličinom. 

IdentityHashMapnjega = novi IdentityHashMap();

2. IdentityHashMap(int expectMaxSize):  Konstruira novu praznu kartu s navedenom očekivanom maksimalnom veličinom. 

IdentityHashMapihm = new IdentityHashMap(int očekivanaMaxSize);

3. IdentityHashMap(Mapa m):  Konstruira novu hash mapu identiteta koja sadrži preslikavanja ključeva i vrijednosti u navedenoj mapi.

IdentityHashMapihm = new IdentityHashMap(Mapa m);

Osnovne operacije na IdentityHashMap

1. Dodavanje elemenata

25 od 100

Za umetanje ili dodavanje mapiranja u IdentityHashMap imamo staviti() i staviSve() metode. put() može umetnuti određeni ključ i vrijednost koju preslikava u određenu mapu. Ako se proslijedi postojeći ključ, prethodna vrijednost se zamjenjuje novom vrijednošću. putAll() kopira sve elemente tj. preslikavanja iz jedne mape u drugu. 

// 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. Uklanjanje elemenata
Za uklanjanje preslikavanja koje koristimo ukloniti() ugrađena metoda klase IdentityHashMap i koristi se za uklanjanje mapiranja bilo kojeg određenog ključa s karte.

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

Možemo pristupiti elementima IdentityHashMapa pomoću dobiti() metodom, primjer toga dat je u nastavku.

// 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. Prijelaz
Možemo koristiti sučelje Iteratora za prelazak preko bilo koje strukture okvira zbirke. Budući da iteratori rade s jednom vrstom podataka, koristimo Entry< ? ? >za razlučivanje dvije odvojene vrste u kompatibilni format. Zatim koristeći next() metodu ispisujemo elemente IdentityHashMapa.

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

Sinkronizirani IdentityHashMap

Ako više niti istovremeno pristupa raspršenoj mapi identiteta i barem jedna od niti strukturno modificira mapu, mora se eksterno sinkronizirati. (Strukturalna modifikacija je bilo koja operacija koja dodaje ili briše jedno ili više mapiranja; samo mijenjanje vrijednosti povezane s ključem koji instanca već sadrži nije strukturna modifikacija.) To se obično postiže sinkronizacijom na nekom objektu koji prirodno enkapsulira mapu. Ako takav objekt ne postoji, mapu treba "zamotati" pomoću Zbirke.synchronizedMap metoda. To je najbolje učiniti u trenutku izrade kako biste spriječili slučajni nesinkronizirani pristup karti. 

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

Metode IdentityHashMap

K– Vrsta ključeva na karti.V– Vrsta vrijednosti mapiranih na karti.

Metode deklarirane u klasi java.util.AbstractMap

Metode deklarirane u sučelju java.util.Map

IdentityHashMap vs  HashMap

• IdentityHashMap koristi operator jednakosti '==' za usporedbu ključeva i vrijednosti, dok HashMap koristi equals metodu za usporedbu ključeva i vrijednosti unutar karte.
• Budući da IdentityHashMap ne koristi equals(), on je relativno brži od HashMapa za objekt sa skupim equals().
• IdentityHashMap ne zahtijeva da ključevi budu nepromjenjivi jer se ne oslanja na equals().

Donji program ilustrira razliku između implementacije 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 je klasa u Javi koja implementira sučelje Map i koristi referentnu jednakost za usporedbu ključeva. Sličan je uobičajenom HashMapu, ali koristi operator == za usporedbu ključeva umjesto metode equals(). To znači da će se dva ključa s istim sadržajem, ali različitim referencama na objekte tretirati kao različiti ključevi u IdentityHashMapu.

Evo primjera kako koristiti IdentityHashMap u Javi:

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 

U ovom primjeru stvaramo IdentityHashMap koji preslikava String ključeve u Integer vrijednosti. Karti dodajemo dva para ključ-vrijednost koristeći dva različita String objekta koji imaju isti sadržaj. Zatim dohvaćamo vrijednosti s karte koristeći iste i različite String objekte. Otkrili smo da možemo dohvatiti vrijednosti s mape pomoću dva različita ključa koji imaju isti sadržaj, ali ne možemo dohvatiti vrijednost pomoću String objekta koji ima isti sadržaj, ali je različita referenca objekta.

Imajte na umu da IdentityHashMap ima malo drugačije ponašanje od običnog HashMapa i općenito je koristan samo u određenim situacijama kada je jednakost referenci važna. U većini slučajeva obični HashMap je dovoljan i prikladniji.

rekha filmska glumica