HashMap en Java avec des exemples
Depuis Java 1.2, HashMap
HashMap est comparable à HashTable mais sans synchronisation. Il permet également le stockage de clés nulles. Cependant, il ne devrait y avoir qu'un seul objet clé nul et un nombre illimité de valeurs nulles. Cette classe ne garantit pas l'ordre de la Map. Importez le fichier java.util. Package HashMap ou sa superclasse pour utiliser cette classe et ses méthodes.
// program for illustrating the HashMap class of java.util package in Java
// First, import the HashMap class
import java.util.HashMap;
// Main class
public class Codeunderscored {
// Declaration of the Main method
public static void main(String[] args)
{
// Creation of a hash map that is empty by declaring the object
// of string and integer type
HashMap<String, Integer> hashMap = new HashMap<>();
//elements' addition to the Map using the standard method put()
hashMap.put("kane", 10);
hashMap.put("rock", 30);
hashMap.put("undertaker", 20);
// Printing the size & content of the Hash Map
System.out.println("Size of Hash Map is:- "+ hashMap.size());
// Printing the items in object of Map
System.out.println(hashMap);
// Checking for the presence of a key and, if so, printing the value using a random element
if (hashMap.containsKey("kane")) {
// Mapping
Integer aVar = hashMap.get("kane");
// Printing the value's corresponding key
System.out.println("value for key"+ " \"kane\" is:- " + aVar);
}
}
}
La syntaxe est la suivante :
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable Il accepte deux paramètres, qui sont les suivants :
- Le type de clés dont cette carte assure le suivi
- Le type des valeurs mappées
HashMap implémente les interfaces sérialisables, clonables et Map
- Les constructeurs HashMap sont les suivants :
- HashMap a quatre constructeurs, dont chacun a un modificateur d'accès public et est répertorié ci-dessous :
- HashMap()
- HashMap (int capacité initiale)
- HashMap (int initialCapacity, float loadFactor)
- HashMap (Carte cartographique)
Nous allons passer en revue chacun des constructeurs et comment les construire à l'aide de programmes Java propres.
Le premier Constructeur :HashMap()
C'est le constructeur par défaut, et il génère une instance HashMap avec une capacité de 16 et un facteur de charge de 0,75.
La syntaxe est la suivante :
HashMap<K, V> hashMap = new HashMap<K, V>();
Exemple :Programme pour montrer comment utiliser le constructeur HashMap() en Java
// Importing the necessary classes required
import java.io.*;
import java.util.*;
// The Primary class for adding elements to the HashMap
class Codeunderscored {
// Main static method in java
public static void main(String args[])
{
// There is absolutely no reason for mentioning the Generic type twice
HashMap<Integer, String> hashMapOne = new HashMap<>();
// Initializing the HashMap using Generics
HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>();
// Adding elements using put method
// Custom input elements
hashMapOne.put(3, "three");
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "Nine");
// Print and show the mapping of HashMap 1
System.out.println("The Mappings of the HashMap hashMapOne are : "+ hashMapOne);
// Print and show the mapping of HashMap 2
System.out.println("The Mapping of the HashMap hashMapTwo are : "+ hashMapTwo);
}
} Le résultat est le suivant :
The Mappings of HashMap hashMapOne are : {3=three, 4=four, 5=five}
The Mapping of HashMap hashMapTwo are : {7=seven, 8=eight, 9=nine} Deuxième constructeur :HashMap(int initialCapacity)
Il génère un objet HashMap avec un facteur de charge de 0,75 et une capacité initiale spécifiée. La syntaxe est la suivante :
HashMap<K, V> hashMap = new HashMap<K, V>(int initialCapacity);
Exemple :Programme de démonstration du constructeur HashMap(int initialCapacity) en Java
// Importing the necessary needed classes
import java.io.*;
import java.util.*;
// The primary class to add HashMap items
class pushElementsToHashMap {
// Main driver method
public static void main(String args[])
{
//It's needless repeating the Generic type.
HashMap<Integer, String> hashMapOne = new HashMap<>(10);
// Initialization of a HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(2);
// Adding elements to object of HashMap
// using put method
// HashMap One
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapOne.put(6, "six");
// HashMap Two
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "nine");
// Print HashMap One elements
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
// Print HashMap Two elements
System.out.println("The Mapping of the HashMap hashMapTwo are : "
+ hashMapTwo);
}
}
La sortie résultante est la suivante :
The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine} Le troisième constructeur :HashMap(int initialCapacity, float loadFactor)
Il génère une instance HashMap avec la capacité initiale et le facteur de charge fournis. La syntaxe est la suivante :
HashMap<K, V> hashMap= new HashMap<K, V>(int initialCapacity, int loadFactor);
Exemple :Programme de démonstration du constructeur HashMap(int initialCapacity,float loadFactor) en Java
// Importing the standard needed classes
import java.io.*;
import java.util.*;
// The primary class for adding elements to the HashMap
class Codeunderscored {
// Declaration of the Main driver method
public static void main(String args[])
{
// It is needless to mention the generic type a second time
HashMap<Integer, String> hashMapOne
= new HashMap<>(5, 0.75f);
// Initialization of a HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(3, 0.5f);
// using the put() method to add customized input elements
// HashMap One
hashMapOne.put(4, "four");
hashMapOne.put(5, "five");
hashMapOne.put(6, "six");
// HashMap Two
hashMapTwo.put(7, "seven");
hashMapTwo.put(8, "eight");
hashMapTwo.put(9, "nine");
// Printing and showing elements in the hashMap one object
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
// Printing and showing elements in the hashMap two object
System.out.println("The Mapping of HashMap the hashMapTwo are : "
+ hashMapTwo);
}
}
La sortie résultante est la suivante :
The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine} HashMap (carte de carte)
Cette méthode produit un objet HashMap avec les mêmes mappages que la carte donnée. La syntaxe est la suivante :
HashMap<K, V> hashMap = new HashMap<K, V>(Map map);
Exemple :Programme de démonstration du constructeur HashMap (Map map) en Java
import java.io.*;
import java.util.*;
class pushElementsToHashMap {
public static void main(String args[])
{
// It is needless mentioning the Generic type twice
Map<Integer, String> hashMapOne = new HashMap<>();
// Add Elements using put method
hashMapOne.put(1, "one");
hashMapOne.put(5, "five");
hashMapOne.put(10, "ten");
// Initializing the HashMap using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>(hashMapOne);
System.out.println("The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
System.out.println("The Mapping of the HashMap hashMapTwo are : "
+ hashMapTwo);
}
} Sortie
The Mappings of the HashMap hashMapOne are : {1=one, 5=five, 10=ten}
The Mapping of the HashMap hashMapTwo are : {1=one, 5=five, 10=ten} Utilisation de HashMap pour effectuer diverses opérations
Ajout d'éléments
La méthode put() peut ajouter un élément à la carte. Le Hashmap, en revanche, ne garde pas la trace de l'ordre d'insertion.
En interne, un hachage différent est généré pour chaque élément, et les éléments sont indexés en fonction de ce hachage pour améliorer l'efficacité.
Exemple :Programme pour ajouter des éléments à un HashMap donné en Java
import java.io.*;
import java.util.*;
class pushElementsToHashMap {
public static void main(String args[])
{
// It is needless mentioning the Generic type twice
HashMap<Integer, String> hashMapOne = new HashMap<>();
// Initialization of a HashMap
// using Generics
HashMap<Integer, String> hashMapTwo
= new HashMap<Integer, String>();
// Add Elements using put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
hashMapTwo.put(1, "Code");
hashMapTwo.put(2, "Underscored");
hashMapTwo.put(3, "Dotcom");
System.out.println(" The Mappings of the HashMap hashMapOne are : "
+ hashMapOne);
System.out.println("The Mapping of HashMap the hashMapTwo are : "
+ hashMapTwo);
}
}
La sortie résultante est la suivante :
The Mappings of the HashMap hm1 are: {1=Code, 2=Underscored, 3=Dotcom}
The Mapping of HashMap the hm2 are: {1=Code, 2=Underscored, 3=Dotcom}
Modification des éléments
Juste au cas où nous souhaitons modifier un élément après son ajout, nous pouvons le faire en utilisant la méthode put () pour l'ajouter à nouveau. Étant donné que les clés sont utilisées pour indexer les éléments de la carte, la valeur de la clé peut être modifiée en ajoutant simplement la valeur mise à jour de la clé que nous voulons modifier.
Exemple :Programme de modification des éléments de la HashMap en Java
import java.io.*;
import java.util.*;
class ChangeElementsOfHashMap {
public static void main(String args[])
{
// Initializing the HashMap
HashMap<Integer, String> hashMapOne
= new HashMap<Integer, String>();
// Changing the specified value using the put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
System.out.println("Initial Map " + hashMapOne);
hashMapOne.put(2, "Coding");
System.out.println("Updated Map " + hashMapOne);
}
} Supprimer un élément
La fonction remove() peut supprimer un élément de la carte. Si une clé est présente dans le mappage, cette fonction prend la valeur de la clé et supprime le mappage pour cette clé.
Exemple :Programme de suppression des éléments du HashMap en Java
import java.io.*;
import java.util.*;
class RemovingHashMapElements{
public static void main(String args[])
{
// Initializing the HashMap
Map<Integer, String> hashMapOne
= new HashMap<Integer, String>();
// Add elements using put method
hashMapOne.put(1, "Code");
hashMapOne.put(2, "Underscored");
hashMapOne.put(3, "Dotcom");
hashMapOne.put(4, "Coding");
// Initializing the HashMap
System.out.println("The Mappings of the HashMap are : "
+ hashMapOne);
// removing the element with a key using the given remove method
hashMapOne.remove(4);
// Finalizing the HashMap
System.out.println("The respective Mappings after removal are : "
+ hashMapOne);
}
} The Mappings of the HashMap are: {1=Code, 2=Underscored, 3=Dotcom, 4=Coding}
The Mappings after removal are: {1=Code, 2=Underscored, 3=Dotcom} Parcours HashMap
L'interface Iterator peut être utilisée pour explorer n'importe quelle structure Collection Framework. Utilisons-nous Entry< ? , ?> pour résoudre les deux types différents dans un format approprié car les itérateurs ne fonctionnent qu'avec un seul type de données. Les éléments de HashMap sont ensuite imprimés à l'aide de la méthode next().
// Example: Program for traversing a Java.util.HashMap
import java.util.HashMap;
import java.util.Map;
public class HashMapTraversal {
public static void main(String[] args)
{
// initialize a HashMap
HashMap<String, Integer> hashMapOne = new HashMap<>();
// Add elements using put method
hashMapOne.put("ken", 31);
hashMapOne.put("white", 50);
hashMapOne.put("brown", 90);
// Iterate through the hash map using a for-each loop
for (Map.Entry<String, Integer> entry : hashMapOne.entrySet())
System.out.println("The key is: " + entry.getKey()
+ " The value is: " + entry.getValue());
}
} Fonctionnalités importantes de HashMap
Une clé est nécessaire pour accéder à une valeur. HashMap tire son nom de la technique de hachage qu'il utilise. Le hachage est une méthode pour transformer une longue chaîne en une courte chaîne représentant la même chaîne. Une valeur plus courte facilite l'indexation et la vitesse de recherche. En interne, HashSet utilise HashMap.
HashMap a quelques fonctionnalités notables :
- Le package java.util inclut HashMap.
- HashMap est une classe abstraite qui étend AbstractMap et fournit une implémentation partielle de l'interface Map.
- Des interfaces clonables et sérialisables sont également implémentées.
- K et V représentent la clé et la valeur dans la formulation précédente.
- Les clés en double ne sont pas autorisées dans HashMap, bien que les valeurs en double soient autorisées.
- Une seule clé ne peut pas contenir plus d'une valeur, tandis que plusieurs clés peuvent contenir une seule valeur.
- HashMap prend également en charge les clés nulles, mais une seule fois avec de nombreuses valeurs nulles.
- Cette classe ne fournit aucune déclaration sur la disposition de la carte, y compris sur le fait qu'elle restera stable dans le temps.
- C'est comparable à HashTable mais sans synchronisation.
Structure interne de HashMap
HashMap inclut en interne un tableau de nœuds, chacun étant représenté par une classe à quatre champs :
- hachage int
- Touche K
- Valeur V
- Nœud suivant
Le nœud contient une référence à son objet, comme on peut le voir. Par conséquent, c'est une liste chaînée.
Les performances de HashMap
Les performances de HashMap sont déterminées par deux paramètres, qui sont les suivants :
- Capacité initiale
- Facteur de charge
Capacité initiale
Il s'agissait de la capacité de HashMap lors de sa création (le nombre de compartiments qu'un HashMap peut contenir lorsque le HashMap est instancié). Il commence par 2^4=16 en Java, ce qui signifie qu'il peut contenir 16 paires clé-valeur.
Facteur de charge
Il s'agit du pourcentage de capacité qui sera augmenté après l'augmentation de la capacité de Hashmap (le pourcentage de remplissage des compartiments après le rehachage). La valeur par défaut en Java est 0.75f, ce qui signifie que le rehashing se produit une fois que 75 % de la capacité a été remplie.
Seuil
Le produit du facteur de charge et de la capacité initiale est le seuil. C'est (16 * 0.75 =12) en Java par défaut. Après avoir saisi 12 paires clé-valeur dans le HashMap, le rehachage se produit.
Ressassage
Le rehashing double la capacité de HashMap lorsqu'il a atteint son seuil. HashMap en Java continue de ressasser dans l'ordre suivant (par défaut) :2^4, 2^5, 2^6, 2^7, etc.
Le rehashing ne sera jamais fait si la capacité de départ est maintenue élevée. Cependant, l'augmenter augmente la complexité temporelle de l'itération. Pour améliorer les performances, il doit être soigneusement sélectionné. Pour déterminer la capacité de départ, considérez le nombre de valeurs attendu. Le facteur de charge le plus populaire est 0,75, ce qui offre un juste équilibre entre les coûts de temps et d'espace. La valeur du facteur de charge varie entre 0 et 1.
Pour votre information, à partir de Java 8, au lieu d'utiliser une liste chaînée pour le chaînage, Java utilise désormais Self Balancing BST. L'avantage de l'auto-équilibrage BST est que nous obtenons le temps de recherche dans le pire des cas (où chaque clé correspond au même emplacement) O(Log n).
HashMap avec synchronisation
HashMap n'est pas synchronisé, ce qui signifie que de nombreux threads peuvent y accéder simultanément. Une synchronisation externe est requise si plusieurs threads visitent cette classe simultanément et qu'au moins l'un d'entre eux manipule sa structure. Elle est accomplie en synchronisant un objet encapsulant la carte. Il peut être enroulé autour de Collections si aucun objet de ce type n'existe. Pour synchroniser HashMap et éviter tout accès involontaire, utilisez synchronizedMap(). Considérez le scénario suivant :
Map m = Collections.synchronizedMap(new HashMap(...));
La carte m est maintenant synchronisée. Si une modification structurelle est apportée après la création de l'itérateur, sauf via la méthode remove de l'itérateur, les itérateurs de cette classe sont infaillibles. Il lèvera ConcurrentModificationException si l'itérateur échoue.
La complexité temporelle de HashMap
Si la fonction de hachage est construite de manière appropriée et que le contenu est réparti uniformément dans les compartiments, HashMap fournit une complexité temporelle constante pour des opérations simples telles que l'obtention et la mise en place.
L'itération sur HashMap est limitée par la capacité de HashMap et le nombre de paires clé-valeur. En substance, il est proportionnel à la capacité + la taille. Dans HashMap, la capacité fait référence au nombre de compartiments. Par conséquent, conserver de nombreux compartiments dans HashMap au début n'est pas une bonne idée.
Applications de HashMap
HashMap est principalement une implémentation de hachage. Cela s'avère pratique lorsque nous devons implémenter rapidement des opérations de recherche, d'insertion et de suppression.
Méthodes de HashMap
K – fait référence au type de touches sur la carte.
V - fait référence au type de valeurs mappées dans la carte donnée.
Effacer()
Les mappages de cette carte sont complètement supprimés à l'aide de cette méthode.
Cloner()
Cette instance de HashMap est renvoyée sous forme de copie superficielle ; les clés et les valeurs ne sont pas dupliquées.
compute(K keyVal, codeFunction rMappingFunction)
Calcule un mappage entre la clé fournie et sa valeur mappée actuelle (ou null s'il n'y a pas de mappage actuel).
computeIfPresent(K keyVal, codeFunction rMappingFunction)
Si les valeurs de la clé spécifiée sont présentes et non nulles, tente de générer un nouveau mappage en fonction de la clé et de sa valeur mappée existante.
containsKey (clé d'objet)
Si cette carte a un mappage pour la clé fournie, elle renvoie true.
containsValue (valeur de l'objet)
Si cette carte correspond par hasard à une ou plusieurs clés de la valeur fournie, elle renvoie true.
entrySet()
Cette méthode est chargée de renvoyer une vue Set des mappages de cette carte.
obtenir (clé d'objet)
Renvoie la valeur à laquelle la clé fournie est mappée, ou null s'il n'existe aucun mappage pour la clé dans ce mappage.
computeIfAbsent(K keyVal, Function mappingFunction)
Tente de calculer la valeur de la clé fournie à l'aide de la fonction de mappage donnée et l'entre dans cette carte si elle n'est pas déjà connectée à une valeur (ou est mappée sur null).
EstVide()
Si cette carte n'a pas de mappages clé-valeur, elle renvoie true.
keySet()
Cette méthode est chargée de renvoyer une vue Set des clés de cette carte.
merge(K keyVal, V valueVal, BiFunction remappingFunction)
Associe la clé fournie à la valeur non nulle donnée si elle n'est pas déjà associée à une valeur ou si elle est nulle.
mettre (touche K, valeur V)
Cette carte associe la valeur fournie à la clé spécifiée.
putAll(Carte m)
Tous les mappages de la carte spécifiée sont copiés sur cette carte.
supprimer (clé d'objet)
Si un mappage pour la clé fournie existe dans ce mappage, il est supprimé.
Taille()
Il est chargé de renvoyer le nombre de mappages clé-valeur dans cette carte.
Valeurs()
Cette méthode renvoie une vue Collection des valeurs de cette carte.
Méthodes héritées de la classe java.util.AbstractMap
est égal à()
Vérifie l'égalité entre l'objet fourni et cette carte.
hashCode()
La méthode est chargée de renvoyer la valeur du code de hachage pour cette carte.
toString()
La méthode toString() est chargée de renvoyer la représentation sous forme de chaîne de cette carte.
Méthodes héritées de l'interface java.util.Map
est égal à()
Vérifie l'égalité entre l'objet fourni et cette carte.
forEach(action BiConsumer)
Effectue l'action fournie pour chaque entrée de cette carte jusqu'à ce que l'action lève une exception. Ou toutes les entrées ont été traitées.
getOrDefault(Clé d'objet, V defaultValue)
Renvoie la valeur à laquelle la clé fournie est mappée, ou defaultValue si aucun mappage pour la clé n'existe dans ce mappage.
hashCode()
Il renvoie la valeur du code de hachage pour cette carte.
putIfAbsent(touche K, valeur V)
Si la clé spécifiée n'a pas encore de valeur (ou est mappée sur null), elle est associée à la valeur donnée et renvoie null ; sinon, il renvoie la valeur actuelle.
supprimer (clé d'objet, valeur d'objet)
L'entrée est supprimée si la clé fournie est actuellement mappée à la valeur spécifiée.
remplacer (touche K, valeur V)
Il est remplacé uniquement si la clé fournie est actuellement mappée à une valeur.
remplacer(touche K, V ancienneValeur, V nouvelleValeur)
Si la clé fournie est actuellement mappée à la valeur fournie, elle est remplacée.
replaceAll(codeFunction)
Remplacez la valeur de chaque entrée par le résultat de l'exécution de la fonction fournie sur cette entrée jusqu'à ce que toutes les entrées aient été traitées. Ou la fonction renvoie une erreur.
Exemple :HashMap en Java
import java.util.*;
public class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();//Creating HashMap
hashMap.put(1,"Apple"); //Add items in hashMap
hashMap.put(2,"Amazon");
hashMap.put(3,"Google");
hashMap.put(4,"Yahoo");
hashMap.put(5,"Twitter");
hashMap.put(6,"Uber");
hashMap.put(7,"DELL");
System.out.println("Iterating through the Hashmap");
for(Map.Entry m : hashMap.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Nous stockons Integer comme clé et String comme valeur dans cet exemple. Ainsi, le type est HashMap
Pour obtenir une instance de Map.Entry, nous devons utiliser la méthode entrySet() de l'interface Map.
Exemple :HashMap n'a pas de clés en double
HashMap n'autorise pas le stockage des clés en double. Si vous essayez de stocker une clé en double avec une valeur différente, la valeur sera remplacée.
import java.util.*;
public class HashMapExample2{
public static void main(String args[]){
HashMap<Integer,String> map=new HashMap<Integer,String>();//Creating HashMap
hashMap.put(1,"Apple"); //Add items in hashMap
hashMap.put(2,"Amazon");
hashMap.put(3,"Google");
hashMap.put(4,"Yahoo");
hashMap.put(5,"Twitter");
hashMap.put(6,"Uber");
hashMap.put(7,"DELL");
hashMap.put(1,"IBM"); //trying to create a duplicate key
System.out.println("Iterating through the Hashmap");
for(Map.Entry m : hashMap.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Exemple :Ajouter des composants à un HashMap Java
Différentes approches pour ajouter des éléments à un HashMap en Java sont présentées ici.
import java.util.*;
class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
System.out.println("The initial item's list : "+hashMap);
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
System.out.println("Results after invoking the put() method ");
for(Map.Entry m:hashMap .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
hashMap.putIfAbsent(260, "Joy");
System.out.println("Results proceeding invoking putIfAbsent() method ");
for(Map.Entry m:hashMap .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
HashMap<Integer,String> hashMapTwo=new HashMap<Integer,String>();
hashMapTwo.put(270,"Brown");
hashMapTwo.putAll(hashMap);
System.out.println(" Results following invoking putAll() method ");
for(Map.Entry m:hashMapTwo .entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
} Exemple :suppression d'entrées d'un HashMap Java
Différentes méthodes de suppression d'éléments sont présentées ici.
import java.util.*;
public class CodeHashMap {
public static void main(String args[]) {
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
hashMap.put(260, "Brown");
System.out.println(" The original list of elements is as follows: "+hashMap);
//key-based removal
hashMap.remove(230);
System.out.println(" The resultant updated list of elements: "+hashMap);
//value-based removal
hashMap.remove(240);
System.out.println("The new updated list of elements: "+hashMap);
//key-value pair based removal
hashMap.remove(260, "Brown");
System.out.println("The resulting updated list of elements: "+hashMap);
}
} Exemple :éléments Replace() dans un HashMap Java
Les différentes approches de remplacement des éléments sont les suivantes :
import java.util.*;
class CodeHashMap{
public static void main(String args[]){
HashMap<Integer,String> hashMap=new HashMap<Integer,String>();
hashMap.put(230,"Ken");
hashMap.put(240,"Mike");
hashMap.put(250,"White");
hashMap.put(260, "Brown");
System.out.println(" The original element's list is:");
for(Map.Entry m:hashMap.entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The new updated list of elements:");
hashMap.replace(240, "Joy");
for(Map.Entry m:hashMap .entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The resultant refreshed list of elements:");
hm.replace(230, "Rock", "Undertaker");
for(Map.Entry m:hashMap.entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
System.out.println("The new resultant list of elements:");
hashMap.replaceAll((k,v) -> "Bright");
for(Map.Entry m:hashMap .entrySet())
{
System.out.println(m.getKey()+" "+m.getValue());
}
}
} Exemple :La distinction entre HashSet et HashMap
HashSet n'inclut que des valeurs, alors que HashMap ne contient que des entrées (clé et valeur).
import java.util.*;
class Laptop {
int id;
String name,owner,manufacturer;
int count;
public Laptop(int id, String name, String owner, String manufacturer, int count) {
this.id = id;
this.name = name;
this.owner = owner;
this.manufacturer = manufacturer;
this. count = count;
}
}
public class CodeHashMap {
public static void main(String[] args) {
//Creating map of Laptops
Map<Integer,Laptop> hashMap=new HashMap<Integer,Laptop>();
//Creating Laptops
Laptop laptopOne=new Laptop(1,"Lenovo","Tyson","Lenovo",2);
Laptop laptopTwo=new Laptop(2,"HP","James","HP",1);
Laptop laptopThree=new Laptop(3,"DELL","Green","DELL",3);
//Adding Laptops to a hash map
hashMap.put(1,laptopOne);
hashMap.put(2,laptopTwo);
hashMap.put(3,laptopThree);
//how to traverse the map
for(Map.Entry<Integer, Laptop> entry:map.entrySet()){
int key=entry.getKey();
Laptop laptop=entry.getValue();
System.out.println(key+" Details:");
System.out.println(laptop .id+" "+laptop.name+" "+laptop.owner+" "+laptop.manufacturer+" "+laptop.count);
}
}
} Conclusion
L'interface Map en Java est implémentée par la classe HashMap, qui nous permet de stocker des paires clé-valeur avec des clés uniques. Les tentatives d'insertion d'une clé en double entraînent l'écrasement de l'élément de la clé correspondante. L'index de clé facilite la mise à jour, la suppression et d'autres opérations.
La classe HashMap se trouve dans le package java.util. En Java, HashMap est similaire à Hashtable. Cependant, il n'est pas synchronisé. Cela nous permet également de stocker des éléments nuls, bien qu'une seule clé nulle doive être utilisée. HashMap
