The Mapa hash tożsamości przybory Mapa interfejs za pomocą Hashtable używanie równości referencyjnej zamiast równości obiektów podczas porównywania kluczy (i wartości). Ta klasa nie jest implementacją Map ogólnego przeznaczenia. Chociaż ta klasa implementuje interfejs Map, celowo narusza ogólną umowę Map, która nakazuje użycie metody równości() podczas porównywania obiektów. Ta klasa jest używana, gdy użytkownik wymaga, aby obiekty były porównywane poprzez odniesienie. Należy do java.util pakiet.

Funkcje IdentityHashMap

• Działa zgodnie z równością odwołań, zamiast używać metody równości(), używa operatora ==.
• Nie jest zsynchronizowany i należy go zsynchronizować zewnętrznie.
• Iteratory to rzuty awaryjne Wyjątek ConcurrentModificationException próbując zmodyfikować podczas iteracji.
• Ta klasa zapewnia stałą wydajność podstawowych operacji (get i put), przy założeniu, że funkcja skrótu tożsamości systemu (System.identityHashCode(Object)) prawidłowo rozdziela elementy pomiędzy segmentami. IdentityHashMap nie używa metody hashCode() zamiast tego używa metody System.identityHashCode(). Jest to znacząca różnica, ponieważ teraz możesz używać zmiennych obiektów jako kluczy w Mapie, których kod mieszający prawdopodobnie ulegnie zmianie, gdy mapowanie zostanie zapisane w IdentityHashMap.

Deklaracja:

klasa publiczna IdentityHashMaprozszerza AbstractMapwdraża MapęMożliwość serializacji Możliwość klonowania 
 

Tutaj K jest kluczowym typem obiektu i V jest wartością Typ obiektu.

W Javie IdentityHashMap jest klasą implementującą interfejs Map. Jest podobna do klasy HashMap, z tą główną różnicą, że IdentityHashMap używa równości referencji zamiast równości obiektów podczas porównywania kluczy.

Podczas gdy HashMap używa metody równości() do porównywania kluczy, IdentityHashMap używa operatora == do porównywania kluczy. Oznacza to, że w IdentityHashMap dwa klucze są uważane za równe wtedy i tylko wtedy, gdy są tym samym obiektem, a nie są równe pod względem zawartości.

jak przekonwertować znak na ciąg

Oto przykład użycia IdentityHashMap w Javie:

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

wyjście;

2 

1

Klasa IdentityHashMap w Javie to oparta na tablicy mieszającej implementacja interfejsu Map, która podczas porównywania kluczy (i wartości) używa równości referencji zamiast równości obiektów.

Zalety używania IdentityHashMap w porównaniu z HashMap:

1. Szybsze wyszukiwania: Ponieważ IdentityHashMap używa równości referencji do porównań, wyszukiwania są szybsze w porównaniu do HashMap, który wykorzystuje równość obiektów.
2. Przydatne do porównywania instancji obiektów: IdentityHashMap jest przydatne w sytuacjach, gdy chcesz porównać instancje obiektów, a nie wartości obiektów.

Wady korzystania z IdentityHashMap:

1. Zużywa więcej pamięci: IdentityHashMap zużywa więcej pamięci w porównaniu do HashMap, ponieważ musi przechowywać odniesienie do obiektu.
2. Nie nadaje się do wszystkich przypadków użycia: IdentityHashMap nie nadaje się do wszystkich przypadków użycia i należy go używać ostrożnie, ponieważ może prowadzić do nieoczekiwanego zachowania w niektórych sytuacjach.

Hierarchia IdentityHashMap

Implementuje Możliwość serializacji Możliwość klonowania Mapa interfejsy i rozszerza StreszczenieMapa klasa.

Przykład:

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

Konstruktorzy IdentityHashMap

Możemy stworzyć instancję Mapa hash tożsamości na dwa sposoby:

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

1. IdentityHashMap():  Konstruuje nową pustą mapę skrótów tożsamości z domyślnym oczekiwanym maksymalnym rozmiarem. 

Mapa hash tożsamościon = nowa IdentityHashMap();

2. IdentityHashMap(int oczekiwanyMaxSize):  Konstruuje nową pustą mapę o określonym oczekiwanym maksymalnym rozmiarze. 

Mapa hash tożsamościihm = nowa IdentityHashMap(int oczekiwanyMaxSize);

3. IdentityHashMap(Mapa m):  Konstruuje nową mapę skrótów tożsamości zawierającą mapowania klucz-wartość na określonej mapie.

Mapa hash tożsamościihm = nowa IdentityHashMap(Mapa m);

podstawowe pytania do rozmowy kwalifikacyjnej w języku Java

Podstawowe operacje na IdentityHashMap

1. Dodawanie elementów

Aby wstawić lub dodać mapowanie do IdentityHashMap, mamy umieścić() I umieść wszystko() metody. put() może wstawić określony klucz i wartość, którą mapuje, do określonej mapy. Jeśli istniejący klucz zostanie przekazany, poprzednia wartość zostanie zastąpiona nową. putAll() kopiuje wszystkie elementy, tj. odwzorowania z jednej mapy na drugą. 

// 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. Usuwanie elementów
Aby usunąć mapowania, których używamy usunąć() wbudowana metoda klasy IdentityHashMap, która służy do usuwania mapowania dowolnego konkretnego klucza z mapy.

// 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. Dostęp do elementów

Dostęp do elementów IdentityHashMap możemy uzyskać za pomocą metody Dostawać() metodę, której przykład podano poniżej.

// 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. Przemierzanie
Możemy użyć interfejsu Iteratora do poruszania się po dowolnej strukturze środowiska zbierania. Ponieważ Iteratory pracują z jednym typem danych, używamy Entry< ? ? >aby rozwiązać dwa oddzielne typy w zgodnym formacie. Następnie metodą next() wypisujemy elementy 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 

Zsynchronizowana mapa tożsamości IdentityHashMap

string.replaceall Java

Jeśli wiele wątków uzyskuje jednocześnie dostęp do mapy skrótów tożsamości i co najmniej jeden z wątków modyfikuje mapę strukturalnie, należy ją zsynchronizować zewnętrznie. (Modyfikacja strukturalna to dowolna operacja, która dodaje lub usuwa jedno lub więcej mapowań; sama zmiana wartości powiązanej z kluczem, który już zawiera instancja, nie jest modyfikacją strukturalną). Zwykle osiąga się to poprzez synchronizację jakiegoś obiektu, który w naturalny sposób hermetyzuje mapę. Jeśli taki obiekt nie istnieje, mapę należy „opakować” za pomocą metody Kolekcje.synchronizowanaMapa metoda. Najlepiej zrobić to w momencie tworzenia, aby zapobiec przypadkowemu, niezsynchronizowanemu dostępowi do mapy. 

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

Metody IdentityHashMap

K– Rodzaj klawiszy na mapie.V– Rodzaj wartości odwzorowanych na mapie.

Metody zadeklarowane w klasie java.util.AbstractMap

Metody zadeklarowane w interfejsie java.util.Map

IdentityHashMap vs  HashMapa

• IdentityHashMap używa operatora równości „==” do porównywania kluczy i wartości, podczas gdy HashMap używa metody równości do porównywania kluczy i wartości wewnątrz Map.
• Ponieważ IdentityHashMap nie używa funkcji równości(), jest ona porównywalnie szybsza niż HashMap w przypadku obiektu z drogimi funkcjami równości().
• IdentityHashMap nie wymaga, aby klucze były niezmienne, ponieważ nie opiera się na funkcji równości().

Poniższy program ilustruje różnicę pomiędzy implementacją 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 to klasa w Javie, która implementuje interfejs Map i wykorzystuje równość referencji do porównywania kluczy. Jest podobna do zwykłej mapy HashMap, ale używa operatora == do porównywania kluczy zamiast metody równości(). Oznacza to, że dwa klucze o tej samej zawartości, ale różnych odniesieniach do obiektów, będą traktowane jako odrębne klucze w IdentityHashMap.

Oto przykład użycia IdentityHashMap w Javie:

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 

W tym przykładzie tworzymy IdentityHashMap, która mapuje klucze String na wartości całkowite. Do mapy dodajemy dwie pary klucz-wartość, używając dwóch różnych obiektów String o tej samej treści. Następnie pobieramy wartości z mapy przy użyciu tych samych i różnych obiektów String. Odkryliśmy, że możemy pobrać wartości z mapy za pomocą dwóch różnych kluczy o tej samej treści, ale nie możemy pobrać wartości za pomocą obiektu String, który ma tę samą treść, ale jest innym odniesieniem do obiektu.

Należy zauważyć, że IdentityHashMap zachowuje się nieco inaczej niż zwykła HashMap i jest ogólnie użyteczna tylko w niektórych sytuacjach, gdzie ważna jest równość referencji. W większości przypadków zwykła HashMap jest wystarczająca i bardziej odpowiednia.

10 ze 100