Menu

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

what is hashmap java

Essayez Notre Instrument Pour Éliminer Les Problèmes

ouverture d'un fichier dat sur mac

Ce didacticiel Java HashMap explique ce qu'est un HashMap en Java et comment l'utiliser. Il comprend comment déclarer, initialiser, itérer, implémenter et imprimer HashMap:

HashMap en Java est une collection basée sur Map et se compose de paires clé-valeur. Un HashMap est désigné par ou. Un élément HashMap est accessible à l'aide d'une clé, c'est-à-dire que nous devons connaître la clé pour accéder à l'élément HashMap.

Un HashMap utilise une technique appelée «Hashing». Dans le hachage, une chaîne plus longue est convertie en une chaîne plus courte en appliquant un algorithme ou une «fonction de hachage». Une chaîne est convertie en une chaîne plus courte car elle permet une recherche plus rapide. Il est également utilisé pour une indexation efficace.

=> Visitez ici pour la série exclusive de didacticiels de formation Java.

Hashmap en Java

Ce que vous apprendrez:

HashMap en Java

Un HashMap est similaire à HashTable à la différence que le HashMap n'est pas synchronisé et autorise des valeurs nulles pour la clé et la valeur.

Certaines des caractéristiques importantes de HashMap sont données ci-dessous:

  1. HashMap est implémenté en Java dans la classe «Hashmap» qui fait partie du package java.util.
  2. La classe HashMap hérite de la classe «AbstractMap» qui implémente partiellement l'interface Map.
  3. HashMap implémente également des interfaces «clonables» et «sérialisables».
  4. HashMap autorise les valeurs en double mais n'autorise pas les clés en double. HashMap autorise également plusieurs valeurs nulles, mais une clé nulle ne peut en être qu'une.
  5. HashMap n'est pas synchronisé et ne garantit pas non plus l'ordre des éléments.
  6. La classe Java HashMap a une capacité initiale de 16 et le facteur de charge par défaut (initial) est de 0,75.

Comment déclarer un HashMap en Java?

Un HashMap en Java fait partie du package java.util. Par conséquent, si nous devons utiliser HashMap dans notre code, nous devons d'abord importer la classe d'implémentation en utilisant l'une des instructions suivantes:

import java.util.*;

OU

import java.util.HashMap;

La déclaration générale de la classe HashMap est:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

Ici, K => type de clés présentes dans la carte

V => type de valeurs mappées aux clés dans la carte

Créer un HashMap

Un HashMap en Java peut être créé comme suit:

import java.util.HashMap; HashMap cities_map = new HashMap ();

L'instruction ci-dessus inclut d'abord la classe HashMap en Java. Ensuite, dans l'instruction suivante, nous créons un HashMap nommé ‘cities_map’ avec le type de clé Integer et Values ​​comme String.

Une fois le HashMap créé, nous devons l'initialiser avec des valeurs.

Comment initialiser la carte de hachage?

Nous pouvons initialiser le HashMap en utilisant la méthode put en mettant des valeurs dans la carte.

Le programme ci-dessous montre l'initialisation de HashMap en Java.

import java.util.*; class Main{ public static void main(String args()){ //create a HashMap and print HashMap colorsMap=new HashMap(); System.out.println('Initial Map: '+colorsMap); //put some initial values into it using put method colorsMap.put(100,'Red'); colorsMap.put(101,'Green'); colorsMap.put(102,'Blue'); //print the HashMap System.out.println('After adding elements:'); for(Map.Entry m:colorsMap.entrySet()){ System.out.println(m.getKey()+' '+m.getValue()); } } }

Production:

Carte initiale: {}
Après avoir ajouté des éléments:
100 Réseau
101 Vert
102 Bleu

Sortie - Initialiser hashmap en Java

Comment fonctionne un HashMap en interne?

Nous savons que HashMap est une collection de paires clé-valeur et utilise une technique appelée «Hashing». En interne, le HashMap est un tableau de nœuds. HashMap utilise array et LinkedList pour stocker des paires clé-valeur.

Vous trouverez ci-dessous une structure d'un nœud de HashMap qui est représenté par programme comme une classe.

Structure d

Comme le montre la représentation de nœud ci-dessus, un nœud a une structure similaire à un nœud de liste liée. Un tableau de ces nœuds est appelé Bucket. Chaque compartiment peut ne pas avoir la même capacité et il peut également avoir plus d'un nœud.

Les performances de HashMap sont influencées par deux paramètres:

(i) Capacité initiale: La capacité est définie comme le nombre de compartiments dans le HashMap. La capacité initiale est définie comme la capacité de l'objet HashMap lors de sa création. La capacité du HashMap est toujours multipliée par 2.

(ii) LoadFactor: LoadFactor est le paramètre qui mesure lors du rechargement - l'augmentation de la capacité sera effectuée.

Notez que si la capacité est élevée, le facteur de charge sera petit car aucun ressassement ne sera nécessaire. De même, lorsque la capacité est faible, le facteur de charge sera élevé car nous devrons répéter fréquemment. Nous devons donc prendre soin de choisir soigneusement ces deux facteurs pour concevoir un hashMap efficace.

Comment itérer un HashMap?

Le HashMap doit être parcouru pour manipuler ou imprimer les paires clé-valeur.

Il y a deux façons de parcourir ou de parcourir le HashMap.

  1. Utilisation de la boucle for
  2. Utilisation de la boucle while et de l'itérateur.

Le programme Java ci-dessous montre l'implémentation de ces deux méthodes.

Tout d'abord, nous récupérons l'ensemble des entrées de HashMap à l'aide de la méthode entrySet, puis nous parcourons l'ensemble en utilisant la boucle for. Ensuite, nous imprimons les paires clé-valeur en utilisant respectivement les méthodes getKey () et getValue ().

Pour parcourir le HashMap à l'aide d'une boucle while, nous définissons d'abord un itérateur pour le HashMap, puis accédons aux paires clé-valeur à l'aide de l'itérateur.

import java.util.*; public class Main{ public static void main(String () args) { //create a HashMap and initialize it HashMap cities_map = new HashMap(); cities_map.put(10, 'MUM'); cities_map.put(1, 'DL'); cities_map.put(20, 'PUN'); cities_map.put(7, 'GOA'); cities_map.put(3, 'HYD'); //print using for loop System.out.println('HashMap using for Loop:'); System.out.println(' KEY VALUE'); for (Map.Entry mapSet : cities_map.entrySet()) { System.out.println(' '+mapSet.getKey() + ' ' + mapSet.getValue()); } //print using while loop with iterator System.out.println('HashMap using while Loop:'); System.out.println(' KEY VALUE'); Iterator iterator = cities_map.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry mapSet2 = (Map.Entry) iterator.next(); System.out.println(' '+mapSet2.getKey() + ' ' + mapSet2.getValue()); } } }

Production:

HashMap utilisant la boucle for:
VALEUR CLÉ
1 DL
3 LONG
20 PUN
7 GOA
10 MAMAN
HashMap utilisant la boucle while:
VALEUR CLÉ
1 DL
3 LONG
20 PUN
7 GOA
10 MAMAN

Sortie - Iterate HashMap en Java

Imprimer une carte de hachage

Voyons un autre exemple d’impression du hashMap à l’aide de la boucle foreach illustrée dans le programme ci-dessous.

import java.util.HashMap; public class Main { public static void main(String() args) { // create a HashMap and initialize HashMap colors = new HashMap(); colors.put('Red', 1); colors.put('Orange', 5); colors.put('Magenta', 8); //print the HashMap System.out.println('HashMap contents:'); System.out.println(' KEY VALUE'); for (String i : colors.keySet()) { System.out.println(' ' + i + ' ' + colors.get(i)); } } }

Production:

Contenu de HashMap:
VALEUR CLÉ
Réseau 1
Magenta 8
Orange 5

4 sorties

Constructeur / Méthodes HashMap en Java

Les tableaux ci-dessous montrent les constructeurs et les méthodes fournis par la classe HashMap en Java.

Constructeurs

Prototype de constructeurDescription
Met tout void putAll (Carte carte)Insère les éléments 'map' spécifiés dans le HashMap.
HashMap () Constructeur par défaut.
HashMap (carte m) Crée un nouveau HashMap à partir de l'objet cartographique donné m.
HashMap (capacité int) Crée un nouveau HashMap avec la capacité initiale donnée par l’argument «capacité».
HashMap (capacité int, float loadFactor) Crée un nouveau HashMap en utilisant les valeurs de capacité et loadFactor fournies par le constructeur.

Méthodes

MéthodePrototype de méthodeDescription
dégager vide clair ()Efface tous les mappages dans le HashMap
est vide booléen isEmpty ()Vérifie si le HashMap est vide. Renvoie vrai si oui.
cloner Clone d'objet ()Renvoie une copie superficielle sans cloner les mappages de clés et de valeurs dans le HashMap.
entrySet Définir l'entréeSet ()Renvoie les mappages dans le HashMap en tant que collection
jeu de clés Définir keySet ()Renvoie un ensemble de clés dans le HashMap.
mettre V put (clé d'objet, valeur d'objet)Insère une entrée clé-valeur dans le HashMap.
putIfAbsent V putIfAbsent (clé K, valeur V)Insère la paire clé-valeur donnée dans le HashMap si elle n'est pas déjà présente.
supprimer V remove (clé d'objet)Supprimez une entrée du HashMap pour la clé donnée.
supprimer boolean remove (clé d'objet, valeur d'objet)Supprime la paire clé-valeur donnée du HashMap.
calculer Calcul V (touche K, fonction de remappage BiFonction)Calcule le mappage à l'aide de la «fonction de remappage» pour la clé donnée et sa valeur actuelle ou sa valeur nulle.
Méthode Prototype de méthodeDescription
computeIfAbsent V computeIfAbsent (touche K, fonction de mappage de fonction)Calcule le mappage à l’aide de ‘mappingFunction’ et insère des paires clé-valeur si elle n’est pas déjà présente ou est nulle.
computeIfPresent V computeIfPresent (touche K, fonction de remappage BiFonction)Calcule un nouveau mappage à l’aide de la ‘remappingFunction’ à partir de la clé si la clé est déjà présente et non nulle.
contientValeur boolean containsValue (valeur de l'objet)Vérifie si la valeur donnée existe dans le HashMap et renvoie true si oui.
contientKey boolean containsKey (clé d'objet)Vérifie si la clé donnée est présente dans le HashMap et renvoie true si oui.
équivaut à booléen est égal à (objet o)Compare un objet donné avec le HashMap.
pour chaque void forEach (action BiConsumer)Exécute une «action» donnée pour chacune des entrées du HashMap.
obtenir V get (clé d'objet)Renvoie l'objet contenant la clé donnée avec la valeur associée.
getOrDefault V getOrDefault (clé d'objet, V defaultValue)Renvoie la valeur à laquelle la clé donnée est mappée. S'il n'est pas mappé, renvoie la valeur par défaut.
est vide booléen isEmpty ()Vérifie si le HashMap est vide.
aller Fusion V (clé K, valeur V, fonction de remappage BiFonction)Vérifie si la clé donnée est nulle ou non associée à une valeur, puis l'associe à une valeur non nulle à l'aide de remappingFunction.
remplacer V remplacer (clé K, valeur V)Remplace la valeur donnée pour la clé spécifiée.
remplacer boolean replace (clé K, V oldValue, V newValue)Remplace l'ancienne valeur de la clé donnée par la nouvelle valeur
remplace tout void replaceAll (fonction BiFonction)Exécute la fonction donnée et remplace toutes les valeurs du HashMap par le résultat de la fonction.
valeurs Valeurs de collection ()Renvoie la collection de valeurs présentes dans le HashMap.
Taille taille int ()Renvoie la taille du nombre d'entrées dans le HashMap.

Implémentation de Hashmap

Ensuite, nous implémenterons la plupart de ces fonctions dans un programme Java pour mieux comprendre leur fonctionnement.

Le programme Java suivant montre une implémentation de HashMap en Java. Notez que nous avons utilisé la plupart des méthodes décrites ci-dessus.

import java.util.*; public class Main { public static void main(String args()) { HashMap hash_map = new HashMap(); hash_map.put(12, 'Leo'); hash_map.put(2, 'Seville'); hash_map.put(7, 'Lacy'); hash_map.put(49, 'Lily'); hash_map.put(3, 'Dillon'); System.out.println('HashMap contents:'); System.out.println(' KEY VALUE'); //display HashMap contents Set setIter = hash_map.entrySet(); Iterator map_iterator = setIter.iterator(); while(map_iterator.hasNext()) { Map.Entry map_entry = (Map.Entry)map_iterator.next(); System.out.println(' '+ map_entry.getKey() + ' ' + map_entry.getValue()); } //get value for the given key String var= hash_map.get(2); System.out.println('Value at index 2 is: '+var); //delete value given the key hash_map.remove(3); System.out.println('Hashmap after removal:'); System.out.println(' KEY VALUE'); Set iter_set = hash_map.entrySet(); Iterator iterator = iter_set.iterator(); while(iterator.hasNext()) { Map.Entry mentry = (Map.Entry)iterator.next(); System.out.println(' '+mentry.getKey() + ' ' + mentry.getValue() ); } } }

Production:

Contenu de HashMap:
VALEUR CLÉ
49 Lily
2 Séville
3 Dillon
7 Dentelle
12 Lion
La valeur à l'indice 2 est: Séville
Hashmap après suppression:
VALEUR CLÉ
49 Lily
2 Séville
7 Dentelle
12 Lion

5 sortie

Trier HashMap en Java

En Java, HashMap ne conserve pas la commande. Par conséquent, nous devons trier les éléments dans le HashMap. Nous pouvons trier les éléments dans le HashMap en fonction des clés ou des valeurs. Dans cette section, nous aborderons les deux approches de tri.

Trier HashMap par clés

import java.util.*; public class Main { public static void main(String() args) { //create and initialize a HashMap HashMap colors_map = new HashMap(); colors_map.put(9, 'Magenta'); colors_map.put(11, 'Yellow'); colors_map.put(7, 'Cyan'); colors_map.put(23, 'Brown'); colors_map.put(5, 'Blue'); colors_map.put(3, 'Green'); colors_map.put(1, 'Red'); //print the unsorted HashMap by getting a set and using iterator System.out.println('Unsorted HashMap:'); Set set = colors_map.entrySet(); Iterator iterator = set.iterator(); while(iterator.hasNext()) { Map.Entry me = (Map.Entry)iterator.next(); System.out.print(me.getKey() + ': '); System.out.println(me.getValue()); } //create a treemap from given HashMap so that the keys are sorted Map map = new TreeMap(colors_map); System.out.println('HashMap Sorted on keys:'); //print the sorted HashMap Set set2 = map.entrySet(); Iterator iterator2 = set2.iterator(); while(iterator2.hasNext()) { Map.Entry me2 = (Map.Entry)iterator2.next(); System.out.print(me2.getKey() + ': '); System.out.println(me2.getValue()); } } }

Production:

HashMap non trié:
1: Réseau
3: vert
5: bleu
7: cyan
23: Marron
9: magenta
11: jaune
HashMap trié sur les clés:
1: Réseau
3: vert
5: bleu
7: cyan
9: magenta
11: jaune
23: Marron

Trier Hashmap par clés - sortie

Dans le programme ci-dessus, nous voyons qu'une fois que le hashmap est défini et rempli de valeurs, nous créons un treemap à partir de ce hashmap. Lorsque le hashmap est converti en un treemap, ses clés sont automatiquement triées. Ainsi, lorsque nous affichons ce treemap, nous obtenons la carte triée sur les clés.

outils de craquage de mot de passe pour Windows 7

Trier HashMap par valeurs

Pour trier un HashMap en fonction de valeurs, nous convertissons d'abord le hashmap en LinkedList. Ensuite, nous utilisons la méthode Collections.sort avec le comparateur pour trier la liste. Cette liste est ensuite reconvertie en HashMap. Le HashMap trié est ensuite imprimé.

import java.util.*; public class Main { public static void main(String() args) { //Create and initialize the HashMap HashMap colors_map = new HashMap(); colors_map.put(5, 'B'); colors_map.put(11, 'O'); colors_map.put(3, 'I'); colors_map.put(13, 'R'); colors_map.put(7, 'G'); colors_map.put(1, 'V'); colors_map.put(9, 'Y'); //print the HashMap using iterator after converting to set System.out.println('Unsorted HashMap:'); Set set = colors_map.entrySet(); Iterator iterator = set.iterator(); while(iterator.hasNext()) { Map.Entry map_entry = (Map.Entry)iterator.next(); System.out.print(map_entry.getKey() + ': '); System.out.println(map_entry.getValue()); } //call sortByValues method that returns a sorted Map. Map c_map = sortByValues(colors_map); System.out.println('HashMap sorted on values:'); //print the sorted HashMap Set set2 = c_map.entrySet(); Iterator iterator2 = set2.iterator(); while(iterator2.hasNext()) { Map.Entry map_entry2 = (Map.Entry)iterator2.next(); System.out.print(map_entry2.getKey() + ': '); System.out.println(map_entry2.getValue()); } } private static HashMap sortByValues(HashMap hash_map) { //create a LinkedList from HashMap List list = new LinkedList(hash_map.entrySet()); // use Collections.sort method with Comparator to sort the list Collections.sort(list, new Comparator() { public int compare(Object o1, Object o2) { return ((Comparable) ((Map.Entry) (o1)).getValue()) .compareTo(((Map.Entry) (o2)).getValue()); } }); //create a HashMap from linkedlist which preserves the order HashMap sortedHashMap = new LinkedHashMap(); for (Iterator it = list.iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); sortedHashMap.put(entry.getKey(), entry.getValue()); } return sortedHashMap; } }

Production:

HashMap non trié:
1: V
3: je
5: B
7: G
9: et
11: O
13: R
HashMap trié sur les valeurs:
5: B
7: G
3: je
11: O
13: R
1: V
9: et

output - Trier le HashMap par valeurs

Concurrent HashMap en Java

Dans HashMap normal, nous ne serons pas en mesure de modifier les éléments au moment de l'exécution ou pendant l'itération.

La mise en œuvre d'une carte simultanée est illustrée ci-dessous:

import java.util.*; import java.util.concurrent.ConcurrentHashMap; public class Main { public static void main(String() args) { //declare and initialize ConcurrentHashMap Map cCMap = new ConcurrentHashMap(); cCMap.put('1', '10'); cCMap.put('2', '10'); cCMap.put('3', '10'); cCMap.put('4', '10'); cCMap.put('5', '10'); cCMap.put('6', '10'); //print the initial ConcurrentHashMap System.out.println('Initial ConcurrentHashMap: '+cCMap); //define the iterator over the keys of ConcurrentHashMap Iterator it = cCMap.keySet().iterator(); //change one of the keys using iterator while(it.hasNext()){ String key = it.next(); if(key.equals('3')) cCMap.put(key+'c_map', 'c_map'); } //print the changed ConcurrentHashMap System.out.println(' ConcurrentHashMap after iterator: '+cCMap); } }

Production:

ConcurrentHashMap initial: {1 = 10, 2 = 10, 3 = 10, 4 = 10, 5 = 10, 6 = 10}
ConcurrentHashMap après l'itérateur: {1 = 10, 2 = 10, 3 = 10, 4 = 10, 5 = 10, 6 = 10, 3c_map = c_map}

Produit - Mise en œuvre de la carte simultanée

Notez que si nous avions effectué la même opération avec HashMap, cela aurait lancé ConcurrentModificationException.

Java Map contre HashMap

Faisons un tableau de certaines des différences entre Map et HashMap en Java.

CarteHashMap
C'est une interface abstraite.Est une implémentation de l'interface Map.
L'interface doit être implémentée par d'autres classes pour que ses fonctionnalités soient disponibles.Est une classe concrète et des objets de classe peuvent être créés pour obtenir la fonctionnalité.
L'implémentation d'interface de carte comme TreeMap n'autorise pas les valeurs nulles.Autorise les valeurs et les clés nulles.
TreeMap n'autorise pas les valeurs en double.Il peut avoir des valeurs en double.
Un ordre naturel des objets est maintenu.Aucun ordre d'entrée n'est conservé dans HashMap.

Questions fréquemment posées

Q # 1) Pourquoi HashMap est-il utilisé en Java?

Répondre: HashMap étant la collection de paires clé-valeur aide à rechercher les données en se basant uniquement sur la clé. De plus, comme il utilise des techniques de hachage, il fournit une recherche efficace des données.

Q # 2)Comment créer une carte de hachage?

Répondre: Un HashMap peut être créé en instanciant la classe «HashMap» du package java.util. Un hashMap avec des clés de type integer et des valeurs de type string peut être créé comme suit:

HashMap myMap= new HashMap();

Q # 3)HashMap est-il commandé en Java?

Répondre: Non, le HashMap n'est pas commandé en Java. Il n'est pas utilisé dans Java à cette fin mais est utilisé pour stocker des éléments dans des paires clé-valeur.

Q # 4)HashMap est-il thread-safe?

Répondre: NON, le hashMap n'est pas thread-safe en Java.

Q # 5)Quel est HashMap ou ConcurrentHashMap plus rapide?

Répondre: HashMap est plus rapide que ConcurrentHashMap. La raison est que HashMap ne fonctionne généralement que sur un seul thread, donc ses performances sont bonnes. Cependant, comme son nom l'indique, HashMap simultané est simultané et peut fonctionner simultanément sur plusieurs threads.

Conclusion

Dans ce tutoriel, nous avons compris le fonctionnement de HashMap avec une autre variante de HashMap appelée ConcurrentHashMap. Nous avons vu des constructeurs, des méthodes et des exemples de HashMap. Nous avons également discuté de ConcurrentHashMap avec son exemple.

Dans nos prochains didacticiels, nous en apprendrons davantage sur les collections Java.

=> Cliquez ici pour voir de A à Z des didacticiels de formation Java ici.

lecture recommandée

^