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 :

import java.util.HashMap;
HashMap<String, String> nomDeLaHashMap = new HashMap<String, String>();

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 :

import java.util.HashMap;
public class Main { 
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

import java.util.HashMap;
public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

{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 :

public class Main { 
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

{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 :

public class Main { 
    public static void main(String[] args) { 
        HashMap<Integer, String> 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 :

{ }

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 :

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

public class Main {
    public static void main(String[] args) { 
        HashMap<Integer, String> 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 :

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 :

public class Main { 
    public static void main(String[] args) {
        HashMap<Integer, String> 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 :

true 
false