Présentation de la collection HashMap

1. Un ensemble de paires clé-valeur.

En Java, une autre collection intéressante (au sens large) est Map. Parfois, cette structure de données est également appelée dictionnaire.

Il est similaire à la Setcollection, mais il stocke un ensemble de "paires" d'éléments plutôt qu'un ensemble d'éléments. Chaque paire dans a se Mapcompose de deux éléments : une "clé" et une "valeur".

Supposons que vous souhaitiez que votre programme stocke les noms des employés et leurs salaires, ou les noms de vos collègues et leur âge. Ensuite, vous auriez besoin d'un tableau comme celui-ci:

Chaque ligne contient quelques valeurs. Nous appellerons le nom la clé de la paire et l'âge la valeur de la paire .

L'ensemble de ces paires est notre carte ( Map).

La clé d'une paire peut être n'importe quoi sauf null. Les clés doivent être uniques : une carte ne peut pas contenir deux clés identiques.

2. HashMapclasse

La HashMapclasse est le type de collection le plus populaire Map. D'une part, il est très similaire à HashSet et possède toutes ses méthodes. D'un autre côté, c'est comme une liste ( ArrayList) qui peut utiliser des mots (ou n'importe quoi d'autre) comme indices.

Vous pouvez créer un HashMapen utilisant une déclaration comme celle-ci :

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

Où KeyTypeest le type des clés dans les paires stockées et ValueTypeest le type des valeurs dans les paires stockées dans la HashMapcollection.

La HashMapclasse a des méthodes comme celle-ci :

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

Ajouter des éléments à unHashMap

Les éléments sont ajoutés à une carte par paires à l'aide de la put()méthode. La clé est passée en premier argument et la valeur est passée en second.

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Lors de l'ajout d'une paire clé-valeur, si la clé existe déjà dans la collection, l'ancienne valeur est remplacée par la nouvelle valeur.

Ce comportement fait de HashMapa un tableau ou une liste dont les indices sont des mots ( String) au lieu de nombres.

3. Sous-ensembles de a HashMap: le jeu de clés

Disons que nous voulons simplement afficher toutes les entrées dans un HashMapsur l'écran. Comment faisons-nous cela? Pour ce faire, nous devons savoir comment parcourir toutes les entrées du fichier HashMap. Cela peut se faire de plusieurs manières.

Le moyen le plus simple consiste à boucler sur les touches

HashMaples entrées ne sont pas numérotées séquentiellement, donc une boucle avec un compteur ne fonctionnera pas ici. Mais nous pouvons obtenir un ensemble de clés en utilisant la keySet()méthode, et vous savez déjà comment itérer sur un ensemble :

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

La keySet()méthode renvoie un ensemble de clés. Vous pouvez utiliser cet ensemble de deux façons :

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. Boucler sur des paires clé-valeur

Il existe également une méthode plus compliquée : vous pouvez transformer a Mapen un ensemble de paires clé-valeur , puis boucler sur les éléments de l'ensemble, comme nous l'avons déjà appris.

La HashMapcollection a une classe d'assistance qui stocke une paire clé-valeur. Il ressemble approximativement à ceci :

class Entry<KeyType, ValueType>
{
   private KeyType key;
   private ValueType value;

   public KeyType getKey()
   {
      return this.key;
   }

   public ValueType getValue()
   {
      return this.value;
   }
}

Le résultat de l'appel de la entrySet()méthode sur un objet sera un :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

Set<Entry<KeyType, ValueType>> name = map.entrySet();

Ici, nous avons la Setclasse générique avec un paramètre de type, qui à son tour est un type générique ( Entry) avec deux paramètres de type.

Il est très facile pour un débutant de s'embrouiller à ce sujet. Mais une fois que vous avez compris, vous pouvez écrire du code comme :

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Cela dit, ce code peut être un peu simplifié :

Tout d'abord, vous pouvez ignorer la création d'une variable distincte pour entrieset appeler à la place la entrySet()méthode directement dans la forboucle :

for(Map.Entry<String, Integer> pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Deuxièmement, vous pouvez utiliser l'opérateur récemment introduit varpour déduire automatiquement le type de la paire clé-valeur :

for(var pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Pas mal, hein ?

5. Comparaison de ArrayListetHashMap

A HashMapressemble fortement à an ArrayListqui permet d'utiliser des chaînes (ou d'autres types) comme index (les clés).

Si vous utilisez Integerpour les clés dans un HashMap, cela devient encore plus similaire à un ArrayList. Comparons:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}