human
Quelle est la meilleure façon d'itérer sur les éléments d'une ```HashMap```
gpt
Extrait de la référence Comment itérer sur une carte en Java:
Il existe plusieurs façons d'itérer sur une ```Map``` en Java. Passons en revue les méthodes les plus courantes et examinons leurs avantages et leurs inconvénients. Étant donné que toutes les cartes en Java implémentent l'interface Map, les techniques suivantes fonctionneront pour n'importe quelle implémentation de carte (```HashMap```, ```TreeMap```, ```LinkedHashMap```, ```Hashtable```, etc.)

Méthode n°1: Itérer sur les entrées à l'aide d'une boucle For-Each.
C'est la méthode la plus courante et préférable dans la plupart des cas. Elle doit être utilisée si vous avez besoin à la fois des clés et des valeurs de la carte dans la boucle.
```Map map = new HashMap();
for (Map.Entry entry : map.entrySet()) {
    System.out.println("Clé = " + entry.getKey() + ", Valeur = " + entry.getValue());
}
```
Notez que la boucle For-Each a été introduite en Java 5, donc cette méthode ne fonctionne que dans les versions plus récentes du langage. De plus, une boucle For-Each lancera une ```NullPointerException``` si vous essayez d'itérer sur une carte qui est nulle, donc avant d'itérer, vous devez toujours vérifier les références nulles.

Méthode n°2: Itérer sur les clés ou les valeurs à l'aide d'une boucle For-Each.
Si vous avez seulement besoin des clés ou des valeurs de la carte, vous pouvez itérer sur keySet ou values au lieu de entrySet.
```Map map = new HashMap();
// Itérer uniquement sur les clés
for (Integer key : map.keySet()) {
    System.out.println("Clé = " + key);
}
// Itérer uniquement sur les valeurs
for (Integer value : map.values()) {
    System.out.println("Valeur = " + value);
}
```
Cette méthode offre un léger avantage de performance par rapport à l'itération de ```entrySet``` (environ 10% plus rapide) et est plus propre.

Méthode n°3: Itérer à l'aide d'un itérateur.
Utilisation de génériques:
```Map map = new HashMap();
Iterator> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = entries.next();
    System.out.println("Clé = " + entry.getKey() + ", Valeur = " + entry.getValue());
}
```
Sans génériques:
```Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    Integer key = (Integer)entry.getKey();
    Integer value = (Integer)entry.getValue();
    System.out.println("Clé = " + key + ", Valeur = " + value);
}
```
Vous pouvez également utiliser la même technique pour itérer sur ```keySet``` ou les valeurs.
Cette méthode peut sembler redondante, mais elle a ses propres avantages. Tout d'abord, c'est la seule façon d'itérer sur une carte dans les anciennes versions de Java. L'autre caractéristique importante est que c'est la seule méthode qui vous permet de supprimer des entrées de la carte pendant l'itération en appelant ```iterator.remove()```. Si vous essayez de le faire pendant une itération For-Each, vous obtiendrez des "résultats imprévisibles" selon la documentation Java.
Du point de vue des performances, cette méthode est équivalente à une itération For-Each.

Méthode n°4: Itérer sur les clés et rechercher les valeurs (inefficace).
```Map map = new HashMap();
for (Integer key : map.keySet()) {
    Integer value = map.get(key);
    System.out.println("Clé = " + key + ", Valeur = " + value);
}
```
Cela peut sembler être une alternative plus propre à la méthode n°1, mais en pratique, c'est assez lent et inefficace car obtenir les valeurs par une clé peut prendre du temps (cette méthode dans différentes implémentations de carte est de 20% à 200% plus lente que la méthode n°1). Si vous avez FindBugs installé, il détectera cela et vous avertira d'une itération inefficace. Cette méthode doit être évitée.

Conclusion:
Si vous avez seulement besoi