Itérer à travers HashMap en Java
HashMap contient des données dans des paires (clé, valeur) accessibles à l'aide d'un type d'index différent. L'interface Map est implémentée par la classe HashMap, qui nous permet de stocker des clés. Depuis Java 1.2, hashMap fait partie du framework de collections Java. En interne, il utilise une technique de hachage relativement rapide.
Qu'est-ce qu'un HashMap en Java ?
HashMap est un conteneur de stockage de paires clé-valeur. Chaque clé correspond à une seule valeur.
Les clés d'un HashMap doivent être uniques. Dans d'autres langages de programmation, HashMap est un tableau associatif ou un dictionnaire. Les HashMaps utilisent plus de mémoire car chaque valeur a une clé correspondante. Le temps nécessaire pour supprimer et insérer des données est constant. Vous pouvez stocker des valeurs nulles dans HashMaps.
Dans HashMap, un Map.entry représente une paire clé-valeur. La méthode entrySet de HashMap renvoie une vue définie des mappages de la carte. Avec la méthode keySet, vous pouvez obtenir une liste de clés.
Itérer sur HashMap dans les exemples Java
La syntaxe est la suivante :
public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K,V>, Clonnable, Serial
Dans cet exemple, nous allons apprendre à itérer sur les clés, les valeurs et les mappages clé/valeur d'un Java HashMap. Pour suivre cet exemple, vous devez être familiarisé avec les concepts de programmation Java suivants :
- HashMap en Java
- boucle for-each en Java
- Interface d'itérateur en Java
Différentes méthodes de traversée
Nous pouvons parcourir les paires clé-valeur répertoriées ci-dessous et détaillées comme suit :
Méthodes :
- Utilisation d'un itérateur
- Boucle avec amélioration (boucle pour chaque)
- Utiliser la méthode forEach()
- Itérer dans un HashMap avec une boucle for
Explorons ce que fait chacune de ces méthodes avant de les utiliser pour parcourir une carte :
- entrySet() - produit une vue de collection de carte dont les éléments sont tirés de la carte. Dans entrySet(), la clé est renvoyée par entry.getKey() et la valeur est renvoyée par entry.getValue().
- keySet() - renvoie une liste de toutes les clés de cette carte.
- values() - renvoie une liste de toutes les valeurs de cette carte.
Voyons comment ces stratégies fonctionnent dans la pratique.
Utiliser un itérateur
Iterator est une interface de package java.util utilisée pour parcourir une collection. Par conséquent, il n'y a pas grand-chose à dire sur les itérateurs, nous allons donc proposer quelques méthodes d'interface Iterator pour parcourir HashMap.
- hm.entrySet() est utilisé pour récupérer toutes les paires clé-valeur de la carte. En interne, un ensemble est composé d'entrées et de magasins.
- hm.entrySet().iterator() renvoie un itérateur qui fonctionne comme un curseur et avance de la première à la dernière entrée de l'ensemble.
- hmIterator.hasNext() renvoie un booléen s'il y a un élément suivant dans l'ensemble.
- hmIterator.next() -L'élément suivant (Map.Entry) de l'ensemble est renvoyé via hmIterator.next().
- mapElement.getKey() est chargé de renvoyer la clé de la carte associée.
- mapElement.getValue() est chargé de renvoyer la valeur de la carte associée.
Exemple :Programme pour traverser le HashMap en Java
Exemple 1 :Utilisation de l'itérateur
// Importing required classes
import java.util.*;
// Main class
class Codeunderscored {
// Main driver method
public static void main(String[] args)
{
// Creating an Hashmap of string-integer pairs
// It contains student name and their marks
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to above HashMap
// using put() method
hm.put("Codeunderscored", 54);
hm.put("A computer portal", 80);
hm.put("For code", 82);
// Printing all elements of HashMap
System.out.println("Created hashmap is" + hm);
// Getting an iterator
Iterator hmIterator = hm.entrySet().iterator();
// Display message only
System.out.println(
"HashMap after adding bonus marks:");
// Iterating through Hashmap and
// adding some bonus marks for every student
while (hmIterator.hasNext()) {
Map.Entry mapElement
= (Map.Entry)hmIterator.next();
int marks = ((int)mapElement.getValue() + 10);
// Printing mark corresponding to string entries
System.out.println(mapElement.getKey() + " : "+ marks);
}
}
} Exemple 2 :Classe pour itérer des HashMaps à l'aide d'un Iterator
// importing java libraries.
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
public class Iterate {
public static void main(String[] arguments) {
// creating hash_map.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting value.
hash_map.put(1, "Code");
hash_map.put(2, "Underscored");
// setting up iterator.
Iterator<Entry<Integer, String>> it = hash_map.entrySet().iterator();
// iterating every set of entry in the HashMap.
while (it.hasNext()) {
Map.Entry<Integer, String> set = (Map.Entry<Integer, String>) it.next();
System.out.println(set.getKey() + " = " + set.getValue());
}
}
} Exemple 3 :Itérer dans HashMap à l'aide d'Iterator ()
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
// create a HashMap
HashMap<String, String> companies = new HashMap<>();
companies.put("Google", "Tech");
companies.put("Microsoft", "Tech");
companies.put("Air BNB", "Tourism");
System.out.println("HashMap: " + companies);
// create an object of Iterator
Iterator<Entry<String, String>> iterate1 = companies.entrySet().iterator();
// iterate through key/value mappings
System.out.print("Entries: ");
while(iterate1.hasNext()) {
System.out.print(iterate1.next());
System.out.print(", ");
}
// iterate through keys
Iterator<String> iterate2 = companies.keySet().iterator();
System.out.print("\nKeys: ");
while(iterate2.hasNext()) {
System.out.print(iterate2.next());
System.out.print(", ");
}
// iterate through values
Iterator<String> iterate3 = companies.values().iterator();
System.out.print("\nValues: ");
while(iterate3.hasNext()) {
System.out.print(iterate3.next());
System.out.print(", ");
}
}
} Dans l'exemple ci-dessus, nous parcourons les clés, les valeurs et les mappages clé/valeur de la carte de hachage. Pour parcourir le hashmap, nous avons utilisé la méthode Iterator().
Ici,
hasNext() renvoie true si l'élément suivant du hashmap existe.
next() - renvoie la prochaine entrée du hashmap.
Utilisation de la boucle for-each
Example 1: Program for Traversing through a HashMap in Java
// Using for-each Loop
// Importing required classes
import java.util.*;
// Main class
class Codeunderscored {
// Main method
public static void main(String[] args)
{
// The HashMap accepts a string and integer
// These pair Mappings are for subject name and average marks
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to HashMap
// using put() method
hm.put("Python", 68);
hm.put("Programming in Java", 48);
hm.put("Object Oriented Programming", 50);
// display every element of Map above
System.out.println(" HashMap Created is:" + hm);
// show messages
System.out.println(
"The state of HashMap after the addition of the bonus marks:");
// HashMap Looping
// Using for-each loop
for (Map.Entry mapElement : hm.entrySet()) {
String key = (String)mapElement.getKey();
// Addition of bonus marks to all subjects
int value = ((int)mapElement.getValue() + 8);
// Printing the marks above that correspond to
// subject names
System.out.println(key + " : " + value);
}
}
} La méthode forEach()
La méthode forEach() de HashMap a été implémentée pour la première fois dans Java 8. Elle est utilisée pour parcourir le hashmap. En même temps, il réduit le nombre de lignes de code, comme indiqué ci-dessous :
Exemple 1 :Programme de traversée d'un HashMap en Java
// Using forEach() Method
// Importing required classes
import java.util.*;
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an empty HashMap of string-integer
// pairs
HashMap<String, Integer> hm
= new HashMap<String, Integer>();
// Adding mappings to HashMap
// using put() method
hm.put("Python", 68);
hm.put("Programming in Java", 48);
hm.put("Object Oriented Programming", 50);
// Printing all elements of above HashMap
System.out.println("Created hashmap is" + hm);
// Display message only
System.out.println(
"HashMap after adding bonus marks:");
// Looping through HashMap and adding bonus marks
// using HashMap.forEach()
hm.forEach((k, v)
-> System.out.println(k + " : "
+ (v + 10)));
}
} Exemple 2 :la classe utilise un forEach pour parcourir un HashMap
// importing libraries.
import java.util.HashMap;
import java.util.Map;
// class for iterating HashMap.
public class Iterate{
public static void main(String[] arguments) {
// creating hash_map.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting sets in the hash_map.
hash_map.put(1, "Code");
hash_map.put(2, "Underscored");
// iterating it using forEach.
hash_map.forEach((key,value) -> System.out.println(key + " = " + value));
}
} Exemple 3 :itérer dans HashMap à l'aide de la boucle forEach
import java.util.HashMap;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
// Creating a HashMap
HashMap<String, String> companies = new HashMap<>();
companies.put("Google", "Tech");
companies.put("Microsoft", "Tech");
companies.put("Air BNB", "Tourism");
System.out.println("HashMap: " + companies);
// iterating through key/value mappings
System.out.print("Entries: ");
for(Entry<String, String> entry: companies.entrySet()) {
System.out.print(entry);
System.out.print(", ");
}
// iterating through keys
System.out.print("\nKeys: ");
for(String key: companies.keySet()) {
System.out.print(key);
System.out.print(", ");
}
// iterating through values
System.out.print("\nValues: ");
for(String value: companies.values()) {
System.out.print(value);
System.out.print(", ");
}
}
} Nous avons généré un hashmap nommé Companies dans l'exemple précédent. De plus, nous avons utilisé la boucle forEach pour parcourir les éléments du hashmap dans ce cas. Il convient de noter que nous parcourons les clés, les valeurs et les mappages clé/valeur séparément.
- companies.entrySet() - renvoie une liste de toutes les entrées dans une vue d'ensemble.
- companies.keySet() renvoie une vue d'ensemble de toutes les entreprises critiques.
- values() - renvoie une liste de toutes les valeurs dans une vue définie.
Dans cet exemple, nous avons utilisé la classe Map.Entry. La classe imbriquée renvoie une vue de la carte.
Itérer dans un HashMap avec une boucle for
hash_map est utilisé dans le code ci-dessous.
La fonction entrySet() renvoie une vue d'ensemble des composants mappés. Il est désormais possible d'itérer des paires clé-valeur à l'aide des opérations getValue() et getKey().
Exemple :classe pour itérer HashMap en Java à l'aide d'une boucle for
// importing library.
import java.util.HashMap;
import java.util.Map;
public class Iterate {
public static void main(String[] arguments) {
// creating HashMap.
Map<Integer, String> hash_map = new HashMap<Integer, String>();
// inserting sets.
hash_map.put(1, "code");
hash_map.put(2, "underscored");
// iterating using for loop.
for (Map.Entry<Integer, String> set : hash_map.entrySet()) {
System.out.println(set.getKey() + " = " + set.getValue());
}
}
} Utiliser l'API Stream et Lambdas
L'API Stream et les lambdas sont disponibles en Java depuis la version 8. Ensuite, nous verrons comment utiliser ces stratégies pour itérer une carte.
Utilisation des expressions forEach() et Lambda
Ceci, comme tant d'autres choses dans Java 8, s'avère beaucoup moins compliqué que les alternatives. Nous n'utiliserons que la méthode forEach() pour l'instant :
public void usingLambdaToIterate(Map<String, Integer> map) {
map.forEach((k, v) -> System.out.println((k + ":" + v)));
} Nous n'avons pas besoin de convertir une carte en un ensemble d'entrées dans ce scénario. En fait, nous pouvons commencer ici pour en savoir plus sur les expressions lambda. Bien sûr, nous pouvons parcourir la carte en commençant par les clés :
public void usingLambdaAndKeys(Map<String, Integer> map) {
map.keySet().foreach(k -> System.out.println((k + ":" + map.get(k))));
} De même, nous pouvons utiliser la méthode values() de la même manière :
public void useLambdaToIterateValues(Map<String, Integer> map) {
map.values().forEach(v -> System.out.println(("value: " + v)));
} Utilisation de l'API de flux
L'une des fonctionnalités les plus remarquables de Java 8 est l'API Stream. Vous pouvez également utiliser cette fonctionnalité pour parcourir une carte. Un flux est une collection d'éléments d'une source qui peuvent être agrégés de manière séquentielle et parallèle. De plus, vous pouvez utiliser une collection, une opération IO ou un tableau pour sourcer les données d'un flux.
Lorsque vous effectuez un traitement Stream supplémentaire, l'API Stream doit être utilisée ; sinon, c'est juste un forEach() de base comme mentionné ci-dessus. Pour illustrer le fonctionnement de l'API Stream, considérons l'exemple suivant :
public void UseStreamAPIteration(Map<String, Integer> map) {
map.entrySet().stream()
// ... some other Stream processings
.forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
} Les méthodes keySet() et values() de l'API Stream sont similaires à l'exemple ci-dessus.
Exemple :Utilisation de l'API Stream pour l'itération HashMap
package com.codeunderscored;
import java.util.HashMap;
public class CodeHashMapStreamApi {
public static void main(String[] args) {
HashMap<String, Integer> hMap = new HashMap<>();
hMap.put("fruits", 5);
hMap.put("vegetables", 2);
hMap.put("laptops", 7);
hMap.entrySet().stream().forEach(e -> {
System.out.format("key: %s, value: %d%n", e.getKey(), e.getValue());
});
}
}
L'exemple itère sur un HashMap lors de l'utilisation de l'API de flux. La fonction entrySet renvoie l'ensemble d'entrées et la méthode stream renvoie le flux à partir de l'ensemble d'entrées. Plus tard, nous utilisons forEach pour parcourir le flux.
Itération sur un HashMap contenu dans ArrayList
Les listes sont également applicables en tant que valeurs dans un HashMap. Dans cette situation, nous aurons besoin d'une boucle supplémentaire.
package com.codeunderscored;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class HashMapList {
public static void main(String[] args) {
Map<String, List<String>> m = new HashMap<>();
m.put("colours", Arrays.asList("red", "green", "blue"));
m.put("sizes", Arrays.asList("small", "medium", "big"));
for (Map.Entry<String, List<String>> me : m.entrySet()) {
String key = me.getKey();
List<String> values = me.getValue();
System.out.println("Key: " + key);
System.out.print("Values: ");
for (String e: values) {
System.out.printf("%s ", e);
}
System.out.println();
}
}
} Nous parcourons un HashMap avec ArrayLists comme valeurs dans cet exemple. Pour les boucles, nous en utilisons deux.
Map<String, List<String>> m = new HashMap<>();
m.put("colours", Arrays.asList("red", "green", "blue"));
m.put("sizes", Arrays.asList("small", "medium", "big")); En tant que valeurs, nous définissons un HashMap à l'aide de ArrayLists.
for (Map.Entry<String, List<String>> me : m.entrySet()) { Nous passons en revue l'ensemble d'entrée avec une boucle for améliorée. Une chaîne de clé et une valeur de liste sont attribuées à chaque entrée.
String key = me.getKey();
La méthode getKey est utilisée pour obtenir la clé.
List<String> values = me.getValue();
Avec getValue, nous obtenons la liste.
for (String e: values) {
System.out.printf("%s ", e);
} Nous parcourons la liste de valeurs dans la boucle for interne.
Conclusion
Dans cet article, nous avons examiné les nombreuses façons de parcourir les éléments de la carte en Java. En termes simples, nous pouvons utiliser entrySet(), keySet() ou values() pour extraire le contenu d'un Map(). Comme ce sont tous des ensembles, les principes d'itération sont les mêmes pour chacun d'eux. De plus, nous avons également examiné les expressions Lambda et l'API Stream, qui ne sont disponibles que dans Java 8 et versions ultérieures.
