# Java HashMap : stocker des données dans des paires clé-valeur La classe Java HashMap vous permet de stocker des données dans des paires clé-valeur. Cela facilite non seulement la récupération et la maintenance de votre liste, mais vous offre également de nombreuses possibilités d’accès. Découvrez les méthodes les plus importantes pour manipuler cette structure de données. ## Que sont les HashMaps en Java ? Il existe différentes méthodes pour stocker et récupérer des données. Selon l’utilisation, l’une ou l’autre méthode de stockage peut être plus appropriée. Dans de nombreux cas, la classe Java HashMap est la meilleure solution. Contrairement aux autres méthodes, cette classe stocke les données sous forme de **paires clé-valeur**. Ce concept prévoit que chaque clé (*key*) se voit attribuer exactement une valeur (*value*). Si vous souhaitez récupérer cette valeur, vous pouvez utiliser la clé correspondante et vous obtiendrez toujours le résultat recherché. Les clés et les valeurs peuvent être constituées de types de données très différents, comme des chaînes, des chiffres ou d’autres objets. La classe Java HashMap offre ainsi plusieurs avantages. Elle vous permet tout d’abord d’effectuer une recherche rapide et fructueuse dans le cadre de ce langage de programmation. En même temps, l’approche clé-valeur empêche d’attribuer plusieurs valeurs à une clé. **Les doublons sont donc exclus**. Seuls les objets peuvent être ajoutés plusieurs fois avec des clés différentes. Ce type de stockage et de recherche a également des effets positifs sur les performances par rapport aux listes rigides, qui sont nettement moins flexibles. C’est aussi l’un des grands avantages des Key-Value-Stores, qui utilisent le même principe. Dans les paragraphes suivants, nous vous montrons donc comment créer des HashMaps Java et les utiliser selon vos besoins. ## Comment créer une HashMap ? Pour créer une nouvelle HashMap en Java, vous devez d’abord importer la classe. Pour cela, utilisez la commande Java `import`. Ensuite, vous pouvez créer la map. Voici le code correspondant : ```java import java.util.HashMap; HashMap nomDeLaHashMap = new HashMap(); ``` Les deux types de données, séparés par une virgule (dans ce cas `String, String`), sont la clé et la valeur. ## Création d’une HashMap Java : exemple concret Prenons un exemple concret : nous allons enregistrer une liste de clients qu’une entreprise peut consulter à tout moment. Celle-ci se compose d’un côté d’un nom de client et de l’autre d’un numéro de client. Alors que le numéro de client (dans notre exemple, la clé) est toujours unique, il peut théoriquement y avoir plusieurs clients avec le même nom. Ceux-ci recevraient alors à nouveau un numéro propre. Ce numéro est enregistré comme **type de données entier**, les noms comme **chaînes**. Voici à quoi ressemble la HashMap correspondante en Java : ```java import java.util.HashMap; public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); } } ``` ## Ajouter des éléments Nous avons maintenant la HashMap Java, mais elle est encore complètement vide. Pour ajouter de nouvelles paires clé-valeur, nous utilisons la méthode **put()**. Dans notre exemple, cela se présente comme suit : ```java import java.util.HashMap; public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); System.out.println(listeClients); } } ``` Nous utilisons la commande `System.out.println` pour afficher notre liste de clients. La sortie devrait ressembler à ceci : ```java {1077=Sabine Berron, 15312=Peter Smith, 73329=Maria Grosso} ``` ## Accéder aux éléments Maintenant, nous avons certes créé une liste de clients qui peut théoriquement contenir beaucoup plus d’entrées, mais nous voulons aussi pouvoir accéder aux différents clients. Pour cela, nous transmettons la clé à la méthode **get()**. Voici à quoi cela ressemble : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); System.out.println(listeClients.get(1077)); } } ``` Dans notre sortie, seul le nom « Sabine Berron » devrait alors apparaître. ## Supprimer une ou toutes les entrées Si vous souhaitez supprimer une entrée spécifique, utilisez la méthode **remove()**. Dans la pratique, celle-ci se présente comme suit : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); listeClients.remove(1077); System.out.println(listeClients); } } ``` La sortie ressemble maintenant à ceci : ```java {15312=Peter Smith, 73329=Maria Grosso} ``` Vous avez également la possibilité de supprimer toute la liste. Pour cela, vous utilisez la méthode **clear()**. Nous l’appliquons ainsi à notre exemple : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); listeClients.clear(); System.out.println(listeClients); ``` Nous n’obtenons alors que ceci en sortie : ```java { } ``` ## Déterminer le nombre d’entrées Alors que notre HashMap Java est très claire, vous pouvez bien sûr réaliser des projets beaucoup plus importants avec cette classe. Dans notre exemple, il peut être très intéressant de déterminer le nombre exact d’entrées différentes. Il s’agirait en fin de compte de l’ensemble de votre base de données clients. La méthode appropriée pour cela est **size()**. Voici comment l’utiliser : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); System.out.println(listeClients.size()); } } ``` Dans notre exemple, nous obtenons en sortie le nombre 3. ## Représenter les clés ou les valeurs seules Il est possible d’obtenir une liste qui ne contient que les clés ou les valeurs. La base est une boucle *for-each*. Pour les clés, on utilise la méthode **keySet()** et pour les valeurs, la méthode **values()**. Cette dernière ressemble à ceci : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); for (String i : listeClients.values()) { System.out.println(i); } } } ``` Notre sortie est alors la suivante : ```java Sabine Berron Peter Smith Maria Grosso ``` ## Vérifier la disponibilité d’un élément Il n’est pas seulement possible d’accéder à une certaine entrée, mais aussi de demander si un élément est vraiment contenu dans la HashMap Java. Pour cela, nous utilisons les méthodes **containsKey()** (pour les clés) et **containsValue()** (pour les valeurs). Si l’élément est contenu, nous obtenons la sortie « true ». Si l’élément n’a pas été déposé, le résultat est « false ». Voici un exemple pratique : ```java public class Main { public static void main(String[] args) { HashMap listeClients = new HashMap<>(); listeClients.put(1077, "Sabine Berron"); listeClients.put(15312, "Peter Smith"); listeClients.put(73329, "Maria Grosso"); System.out.println(listeClients.containsKey(15312)); System.out.println(listeClients.containsValue("Stuart Miller")); } } ``` Comme la clé « 15312 » est contenue, mais que la valeur « Stuart Miller » n’a pas été listée, la sortie est la suivante : ```java true false ``` This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-hashmap/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-hashmap/) for AI/LLM consumption.