En Java, HashMap fait partie de la collection Java depuis Java 1.2. Cette classe se retrouve dans java.util emballer. Il fournit l'implémentation de base de l'interface Map de Java. HashMap en Java stocke les données dans des paires (Clé, Valeur) et vous pouvez y accéder via un index d'un autre type (par exemple un Entier). Un objet est utilisé comme clé (index) pour un autre objet (valeur). Si vous essayez d'insérer la clé en double dans HashMap, cela remplacera l'élément de la clé correspondante.

Qu’est-ce que HashMap ?

Carte de hachage Java est similaire à Table de hachage , mais il n'est pas synchronisé. Il permet également de stocker les clés nulles, mais il ne doit y avoir qu'un seul objet clé nulle et il peut y avoir n'importe quel nombre de valeurs nulles. Cette classe ne donne aucune garantie quant à l'ordre de la carte. Pour utiliser cette classe et ses méthodes, vous devez importer java.util.HashMap package ou sa superclasse.

Table des matières

• Qu’est-ce que HashMap ?
• Exemples de cartes de hachage Java
• Déclaration HashMap
• Hiérarchie de Java HashMap
• Création de HashMap en Java
• Constructeurs Java HashMap
• Effectuer diverses opérations sur HashMap
• Complexité de HashMap en Java
• Structure interne de HashMap
• Avantages et inconvénients de Java HashMap

Exemples de cartes de hachage Java

Vous trouverez ci-dessous l'implémentation d'un exemple de Java HashMap :

Java

>

>

Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10>

Carte de hachage Déclaration

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>

Paramètres:

Il faut deux paramètres à savoir les suivants :

• Le type de clés conservées par cette carte
• Le type de valeurs mappées

Remarque : K eys et value ne peuvent pas être un type de données primitif. La clé dans Hashmap est valide si elle implémente Méthode hashCode() et equals() , il doit également être immuable (objet personnalisé immuable) afin que le hashcode et l'égalité restent constants. La valeur dans hashmap peut être n'importe quelle classe wrapper, objets personnalisés, tableaux, n'importe quel type de référence ou même null .

Par exemple : Hashmap peut avoir un tableau comme valeur mais pas comme clé.

HashMap dans Java implémente Sérialisable , Clonable , Carte interfaces.Java HashMap étend RésuméCarte classe. Les sous-classes directes sont LinkedHashMap et Raisons de l’état de l’imprimante .

pile en java

Hiérarchie de Java HashMap

Caractéristiques de Java HashMap

Un HashMap est une structure de données utilisée pour stocker et récupérer des valeurs basées sur des clés. Certaines des caractéristiques clés d'une hashmap incluent :

• Temps d'accès rapide : Les HashMaps fournissent un accès en temps constant aux éléments, ce qui signifie que la récupération et l'insertion d'éléments sont très rapides, généralement d'une complexité temporelle O(1).
• Utilise la fonction de hachage : HashMaps utilise une fonction de hachage pour mapper les clés aux index d'un tableau. Cela permet une recherche rapide des valeurs en fonction des clés.
• Stocke les paires clé-valeur : Chaque élément d'un HashMap se compose d'une paire clé-valeur. La clé est utilisée pour rechercher la valeur associée.
• Prend en charge les clés et valeurs nulles : HashMaps autorise les valeurs et les clés nulles. Cela signifie qu'une clé nulle peut être utilisée pour stocker une valeur et qu'une valeur nulle peut être associée à une clé.
• Pas ordonné: Les HashMaps ne sont pas ordonnés, ce qui signifie que l'ordre dans lequel les éléments sont ajoutés à la carte n'est pas conservé. Cependant, LinkedHashMap est une variante de HashMap qui préserve l'ordre d'insertion.
• Autorise les doublons : HashMaps autorise les valeurs en double, mais pas les clés en double. Si une clé en double est ajoutée, la valeur précédente associée à la clé est écrasée.
• Thread dangereux : Les HashMaps ne sont pas thread-safe, ce qui signifie que si plusieurs threads accèdent simultanément à la même hashmap, cela peut entraîner des incohérences dans les données. Si la sécurité des threads est requise, ConcurrentHashMap peut être utilisé.
• Capacité et facteur de charge : Les HashMaps ont une capacité, qui correspond au nombre d'éléments qu'ils peuvent contenir, et un facteur de charge, qui mesure le degré de remplissage de la hashmap avant son redimensionnement.

Création de HashMap en Java

Comprenons comment nous pouvons créer HashMap en Java avec un exemple mentionné ci-dessous :

Java

>

>

25 false 2>

Constructeurs Java HashMap

HashMap fournit 4 constructeurs et le modificateur d'accès de chacun est public, répertoriés comme suit :

1. Carte de hachage()
2. HashMap (int initialCapacity)
3. HashMap (int initialCapacity, float loadFactor)
4. HashMap(Carte de la carte)

Discutons maintenant des constructeurs ci-dessus un par un et de leur implémentation à l'aide de programmes Java propres.

1. HashMap()

C'est le constructeur par défaut qui crée une instance de HashMap avec une capacité initiale de 16 et un facteur de charge de 0,75.

Syntaxe:

HashMap hm = new HashMap();>

Exemple

Java

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

2. HashMap (int initialCapacity)

Il crée une instance HashMap avec un capacité initiale spécifiée et facteur de charge de 0,75.

Syntaxe:

HashMap hm = new HashMap(int initialCapacity);>

Exemple

Java

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

3. HashMap (int initialCapacity, float loadFactor)

Il crée une instance HashMap avec une capacité initiale spécifiée et un facteur de charge spécifié.

Syntaxe:

HashMap hm = new HashMap(int initialCapacity, float loadFactor);>

Exemple

liste double chaînée

Java

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}>

4. HashMap (Carte)

Il crée une instance de HashMap avec les mêmes mappages que la carte spécifiée.

HashMap hm = new HashMap(Carte);

Java

>

>

Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}>

Effectuer diverses opérations sur HashMap

1. Ajout d'éléments dans HashMap en Java

Afin d'ajouter un élément à la carte, nous pouvons utiliser le mettre() méthode. Cependant, l'ordre d'insertion n'est pas conservé dans le Hashmap. En interne, pour chaque élément, un hachage distinct est généré et les éléments sont indexés en fonction de ce hachage pour le rendre plus efficace.

Java

>

>

Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}>

2. Modification des éléments dans HashMap en Java

Après avoir ajouté les éléments, si nous souhaitons modifier l'élément, cela peut être fait en ajoutant à nouveau l'élément avec le mettre() méthode. Étant donné que les éléments de la carte sont indexés à l'aide des clés, la valeur de la clé peut être modifiée en insérant simplement la valeur mise à jour pour la clé pour laquelle nous souhaitons modifier.

caractère en entier en java

Java

>

>

Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}>

3. Suppression d'un élément de Java HashMap

Afin de supprimer un élément de la Map, nous pouvons utiliser le retirer() méthode. Cette méthode prend la valeur de la clé et supprime le mappage d'une clé de cette carte si elle est présente dans la carte.

Java

>

>

Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}>

4. Traversée de Java HashMap

Nous pouvons utiliser l’interface Iterator pour parcourir n’importe quelle structure du Collection Framework. Étant donné que 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 entrées de HashMap.

Java

>

>

Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>

Complexité de HashMap en Java

HashMap fournit une complexité temporelle constante pour les opérations de base, get et put si la fonction de hachage est correctement écrite et disperse correctement les éléments entre les compartiments. L'itération sur HashMap dépend de la capacité de HashMap et du nombre de paires clé-valeur. En gros, c’est directement proportionnel à la capacité + taille. La capacité est le nombre de compartiments dans HashMap. Ce n'est donc pas une bonne idée de conserver initialement un nombre élevé de compartiments dans HashMap.

Fonctionnalités importantes de HashMap

Pour accéder à une valeur, il faut connaître sa clé. HashMap est connu sous le nom de HashMap car il utilise une technique appelée Hashing. Hachage est une technique de conversion d'une grande chaîne en une petite chaîne qui représente la même chaîne. Une valeur plus courte facilite l’indexation et des recherches plus rapides. Jeu de hachage utilise également HashMap en interne.
Quelques fonctionnalités importantes de HashMap sont :

• HashMap fait partie du package java.util.
• HashMap étend une classe abstraite AbstractMap qui fournit également une implémentation incomplète de l'interface Map.
• Il met également en œuvre un Clonable et Sérialisable interfaces. K et V dans la définition ci-dessus représentent respectivement la clé et la valeur.
• HashMap n'autorise pas les clés en double mais autorise les valeurs en double. Cela signifie qu'une seule clé ne peut pas contenir plus d'une valeur, mais que plusieurs clés peuvent contenir une seule valeur.
• HashMap autorise également une clé nulle, mais une seule fois et plusieurs valeurs nulles.
• Cette classe ne donne aucune garantie quant à l'ordre de la carte ; il ne garantit notamment pas que la commande restera constante dans le temps. Il est à peu près similaire à HashTable mais n'est pas synchronisé.

Structure interne de HashMap

En interne, HashMap contient un tableau de Node et un nœud est représenté comme une classe contenant 4 champs :

1. hachage entier
2. Clé K
3. Valeur V
4. Nœud suivant

On peut voir que le nœud contient une référence à son propre objet. C'est donc une liste chaînée.

Carte de hachage :

Nœud:

noyau Java

Performances de HashMap

Les performances de HashMap dépendent de 2 paramètres qui sont nommés comme suit :

1. Capacité initiale
2. Facteur de charge

1. Capacité initiale – C’est la capacité du HashMap au moment de sa création (C’est le nombre de buckets qu’un HashMap peut contenir lorsque le HashMap est instancié). En Java, il s'agit initialement de 2 ^ 4 = 16, ce qui signifie qu'il peut contenir 16 paires clé-valeur.

2. Facteur de charge – C'est la valeur en pourcentage de la capacité après laquelle la capacité de Hashmap doit être augmentée (c'est le pourcentage de remplissage des seaux après lequel le rehashing a lieu). En Java, il est de 0,75f par défaut, ce qui signifie que le rehachage a lieu après avoir rempli 75 % de la capacité.

3. Seuil – C’est le produit du facteur de charge et de la capacité initiale. En Java, par défaut, c'est (16 * 0,75 = 12). Autrement dit, le rehashing a lieu après l'insertion de 12 paires clé-valeur dans le HashMap.

4. Répéter – Il s’agit du processus consistant à doubler la capacité du HashMap après avoir atteint son seuil. En Java, HashMap continue de répéter (par défaut) dans la séquence suivante – 2^4, 2^5, 2^6, 2^7,…. bientôt.

Si la capacité initiale reste élevée, aucun remaniement ne sera jamais effectué. Mais en le gardant plus élevé, la complexité temporelle de l'itération augmente. Il faut donc le choisir très intelligemment pour augmenter les performances. Le nombre attendu de valeurs doit être pris en compte pour définir la capacité initiale. La valeur de facteur de charge la plus généralement préférée est de 0,75, ce qui offre un bon rapport entre les coûts de temps et d'espace. La valeur du facteur de charge varie entre 0 et 1.

Note: À partir de Java 8, Java a commencé à utiliser Self Balancing BST au lieu d'une liste chaînée pour le chaînage. L'avantage de l'auto-équilibrage de bst est que nous obtenons le pire des cas (lorsque chaque touche correspond au même emplacement) le temps de recherche est O (Log n).

HashMap synchronisé

Comme il est dit que HashMap n'est pas synchronisé, c'est-à-dire que plusieurs threads peuvent y accéder simultanément. Si plusieurs threads accèdent à cette classe simultanément et qu’au moins un thread la manipule structurellement alors il est nécessaire de la synchroniser en externe. Cela se fait en synchronisant un objet qui encapsule la carte. Si aucun objet de ce type n'existe, il peut être enroulé autour de Collections.synchronizedMap() pour synchroniser HashMap et éviter un accès non synchronisé accidentel. Comme dans l'exemple suivant :

Map m = Collections.synchronizedMap(new HashMap(...));>

La Map m est désormais synchronisée. Les itérateurs de cette classe échouent si une modification de structure est effectuée après la création de l'itérateur, de quelque manière que ce soit, sauf via la méthode de suppression de l'itérateur. En cas d'échec d'un itérateur, il lancera ConcurrentModificationException.

Applications de HashMap :

HashMap est principalement la mise en œuvre du hachage. C'est utile lorsque nous avons besoin d'une implémentation efficace des opérations de recherche, d'insertion et de suppression. Veuillez vous référer au applications du hachage pour plus de détails.

Méthodes dans HashMapassociate

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

Méthodes héritées de la classe java.util.AbstractMap

Méthodes héritées de l'interface java.util.Map

Avantages de Java HashMap

• Récupération rapide : Les HashMaps fournissent un accès en temps constant aux éléments, ce qui signifie que la récupération et l'insertion des éléments sont très rapides.
• Stockage efficace : HashMaps utilise une fonction de hachage pour mapper les clés aux index d'un tableau. Cela permet une recherche rapide des valeurs basées sur des clés et un stockage efficace des données.
• La flexibilité : HashMaps autorise les clés et valeurs nulles et peut stocker des paires clé-valeur de n'importe quel type de données.
• Facile à utiliser : HashMaps ont une interface simple et peuvent être facilement implémentés en Java.
• Convient aux grands ensembles de données : HashMaps peut gérer de grands ensembles de données sans ralentir.

Inconvénients de Java HashMap

• Non commandé : Les HashMaps ne sont pas ordonnés, ce qui signifie que l'ordre dans lequel les éléments sont ajoutés à la carte n'est pas conservé.
• Pas thread-safe : Les HashMaps ne sont pas thread-safe, ce qui signifie que si plusieurs threads accèdent simultanément à la même hashmap, cela peut entraîner des incohérences dans les données.
• Les performances peuvent se dégrader : Dans certains cas, si la fonction de hachage n'est pas correctement implémentée ou si le facteur de charge est trop élevé, les performances d'une HashMap peuvent se dégrader.
• Plus complexe que les tableaux ou les listes : Les HashMaps peuvent être plus complexes à comprendre et à utiliser que de simples tableaux ou listes, en particulier pour les débutants.
• Utilisation de la mémoire plus élevée : Étant donné que les HashMaps utilisent un tableau sous-jacent, ils peuvent utiliser plus de mémoire que d'autres structures de données telles que des tableaux ou des listes. Cela peut être un inconvénient si l'utilisation de la mémoire est un problème.

Lisez également

• Hashmap et Treemap
• Hashmap et HashTable
• Articles récents sur Java HashMap

FAQ sur Java HashMap

1. Qu'est-ce qu'un HashMap en Java ?

HashMap en Java est la classe du framework de collection qui peut y stocker des paires clé-valeur.

2. Pourquoi utiliser HashMap en Java ?

HashMap en Java est utilisé pour stocker des paires clé-valeur où chaque clé est unique.

3. Quel est l'avantage de HashMap ?

HashMap est utilisé car il fournit des fonctionnalités telles que :

• Récupération rapide
• Stockage efficace
• Utilisation flexible
• Facile à utiliser
• Convient aux grands ensembles de données