Le IdentityHashMap met en œuvre Carte interface utilisant Table de hachage en utilisant l'égalité de référence à la place de l'égalité d'objet lors de la comparaison des clés (et des valeurs). Cette classe n’est pas une implémentation Map à usage général. Bien que cette classe implémente l'interface Map, elle viole intentionnellement le contrat général de Map qui impose l'utilisation de la méthode equals() lors de la comparaison d'objets. Cette classe est utilisée lorsque l'utilisateur demande que les objets soient comparés via une référence. Il appartient à java.util emballer.

Caractéristiques d'IdentityHashMap

• Il suit l'égalité de référence au lieu d'utiliser la méthode equals(), il utilise l'opérateur ==.
• Il n'est pas synchronisé et doit être synchronisé en externe.
• Les itérateurs sont à lancement rapide ConcurrentModificationException dans une tentative de modification lors de l'itération.
• Cette classe fournit des performances en temps constant pour les opérations de base (get et put) en supposant que la fonction de hachage d'identité du système (System.identityHashCode(Object)) disperse correctement les éléments entre les compartiments. IdentityHashMap n'utilise pas la méthode hashCode() mais utilise la méthode System.identityHashCode(). Il s'agit d'une différence significative car vous pouvez désormais utiliser des objets mutables comme clé dans Map dont le code de hachage est susceptible de changer lorsque le mappage est stocké dans IdentityHashMap.

Déclaration:

classe publique IdentityHashMapétend AbstractMapimplémente la carteSérialisable Clonable 
 

Ici K est le type d'objet clé et V est la valeur Type d'objet.

En Java, IdentityHashMap est une classe qui implémente l'interface Map. Elle est similaire à la classe HashMap, la principale différence étant qu'IdentityHashMap utilise l'égalité de référence au lieu de l'égalité d'objet lors de la comparaison des clés.

Alors que HashMap utilise la méthode equals() pour comparer les clés, IdentityHashMap utilise l'opérateur == pour comparer les clés. Cela signifie que dans un IdentityHashMap, deux clés sont considérées comme égales si et seulement si elles constituent le même objet plutôt que d'être égales en termes de contenu.

recherche linéaire en java

Voici un exemple de la façon dont vous pouvez utiliser un IdentityHashMap en 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  } } 

sortir;

2 

1

La classe IdentityHashMap en Java est une implémentation basée sur une table de hachage de l'interface Map qui utilise l'égalité de référence à la place de l'égalité d'objet lors de la comparaison des clés (et des valeurs).

Avantages de l'utilisation d'IdentityHashMap sur HashMap :

1. Recherches plus rapides : étant donné qu'IdentityHashMap utilise l'égalité de référence à des fins de comparaison, les recherches sont plus rapides que HashMap qui utilise l'égalité d'objet.
2. Utile pour comparer des instances d'objet : IdentityHashMap est utile dans les situations où vous souhaitez comparer des instances d'objet plutôt que des valeurs d'objet.

Inconvénients de l'utilisation d'IdentityHashMap :

1. Utilise plus de mémoire : IdentityHashMap utilise plus de mémoire que HashMap car il doit stocker la référence à l'objet.
2. Ne convient pas à tous les cas d'utilisation : IdentityHashMap ne convient pas à tous les cas d'utilisation et doit être utilisé avec prudence car il peut entraîner un comportement inattendu dans certaines situations.

La hiérarchie d'IdentityHashMap

Il met en œuvre Sérialisable Clonable Carte interfaces et extensions RésuméCarte classe.

Exemple:

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

Constructeurs de IdentityHashMap

Nous pouvons créer une instance de IdentityHashMap de deux manières :

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

1. IdentityHashMap() :  Construit une nouvelle carte de hachage d'identité vide avec une taille maximale attendue par défaut. 

IdentityHashMaplui = nouveau IdentityHashMap();

2. IdentityHashMap (int ExpectMaxSize) :  Construit une nouvelle carte vide avec la taille maximale attendue spécifiée. 

IdentityHashMapihm = new IdentityHashMap (int ExpectMaxSize);

3. IdentityHashMap (Carte m) :  Construit une nouvelle carte de hachage d'identité contenant les mappages clé-valeur dans la carte spécifiée.

IdentityHashMapihm = new IdentityHashMap(Map m);

chaîne de fractionnement c++

Opérations de base sur IdentityHashMap

1. Ajout d'éléments

Pour insérer ou ajouter un mappage dans un IdentityHashMap, nous avons mettre() et putAll() méthodes. put() peut insérer une clé spécifique et la valeur qu'elle mappe dans une carte particulière. Si une clé existante est transmise, la valeur précédente est remplacée par la nouvelle valeur. putAll() copie tous les éléments, c'est-à-dire les mappages d'une carte à une autre. 

// 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. Suppression d'éléments
Pour supprimer les mappages que nous utilisons retirer() une méthode intégrée de la classe IdentityHashMap et est utilisée pour supprimer le mappage d'une clé particulière de la carte.

// 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. Accéder aux éléments

Nous pouvons accéder aux éléments d'un IdentityHashMap en utilisant le obtenir() méthode, l’exemple est donné ci-dessous.

// 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. Traversée
Nous pouvons utiliser l'interface Iterator pour parcourir n'importe quelle structure du Collection Framework. Puisque les itérateurs fonctionnent avec un seul type de données, nous utilisons Entry< ? ? >pour résoudre les deux types distincts dans un format compatible. Ensuite, en utilisant la méthode next(), nous imprimons les éléments de 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 synchronisé

qu'est-ce qu'une pile Java

Si plusieurs threads accèdent simultanément à une carte de hachage d’identité et qu’au moins l’un des threads modifie structurellement la carte, elle doit être synchronisée en externe. (Une modification structurelle est toute opération qui ajoute ou supprime un ou plusieurs mappages ; le simple fait de changer la valeur associée à une clé qu'une instance contient déjà n'est pas une modification structurelle.) Ceci est généralement réalisé par synchronisation sur un objet qui encapsule naturellement la carte. Si aucun objet de ce type n'existe, la carte doit être « enveloppée » à l'aide du Collections.synchronizedMap méthode. Il est préférable de le faire au moment de la création pour éviter tout accès accidentel non synchronisé à la carte. 

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

Méthodes d'IdentityHashMap

K– Le type des clés dans la carte.V– Le type de valeurs mappées dans la carte.

Méthodes déclarées dans la classe java.util.AbstractMap

Méthodes déclarées dans l'interface java.util.Map

IdentityHashMap et  Carte de hachage

• IdentityHashMap utilise l'opérateur d'égalité '==' pour comparer les clés et les valeurs tandis que HashMap utilise la méthode égale pour comparer les clés et les valeurs dans Map.
• Étant donné que IdentityHashMap n'utilise pas equals(), il est comparativement plus rapide que HashMap pour un objet avec equals() coûteux.
• IdentityHashMap ne nécessite pas que les clés soient immuables car elles ne s'appuient pas sur equals().

Le programme ci-dessous illustre la différence entre l'implémentation d'IdentityHashMap et de 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 est une classe en Java qui implémente l'interface Map et utilise l'égalité de référence pour comparer les clés. Il est similaire à un HashMap classique mais il utilise l'opérateur == pour comparer les clés au lieu de la méthode equals(). Cela signifie que deux clés avec le même contenu mais des références d'objet différentes seront traitées comme des clés distinctes dans un IdentityHashMap.

Voici un exemple d'utilisation d'IdentityHashMap en 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 

Dans cet exemple, nous créons un IdentityHashMap qui mappe les clés String à des valeurs entières. Nous ajoutons deux paires clé-valeur à la carte en utilisant deux objets String différents qui ont le même contenu. Nous récupérons ensuite les valeurs de la carte en utilisant des objets String identiques et différents. Nous constatons que nous pouvons récupérer des valeurs de la carte en utilisant les deux clés différentes qui ont le même contenu, mais nous ne pouvons pas récupérer une valeur en utilisant un objet String qui a le même contenu mais est une référence d'objet différente.

Notez qu'IdentityHashMap a un comportement légèrement différent d'un HashMap classique et n'est généralement utile que dans certaines situations où l'égalité des références est importante. Dans la plupart des cas, un HashMap classique est suffisant et plus approprié.

CSS gras