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é­cu­pé­ra­tion et la main­te­nance de votre liste, mais vous offre également de nom­breuses pos­si­bi­li­tés d’accès. Découvrez les méthodes les plus im­por­tantes pour manipuler cette structure de données.

Que sont les HashMaps en Java ?

Il existe dif­fé­rentes méthodes pour stocker et récupérer des données. Selon l’uti­li­sa­tion, l’une ou l’autre méthode de stockage peut être plus ap­pro­priée. Dans de nombreux cas, la classe Java HashMap est la meilleure solution. Con­trai­re­ment 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 exac­te­ment une valeur (value). Si vous souhaitez récupérer cette valeur, vous pouvez utiliser la clé cor­res­pon­dante et vous ob­tien­drez toujours le résultat recherché. Les clés et les valeurs peuvent être cons­ti­tuées de types de données très dif­fé­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 fruc­tueuse dans le cadre de ce langage de pro­gram­ma­tion. 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 dif­fé­rentes. Ce type de stockage et de recherche a également des effets positifs sur les per­for­mances 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 pa­ra­graphes 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 cor­res­pon­dant :

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 en­re­gis­trer une liste de clients qu’une en­tre­prise 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éo­ri­que­ment y avoir plusieurs clients avec le même nom. Ceux-ci re­ce­vraient alors à nouveau un numéro propre. Ce numéro est en­re­gis­tré comme type de données entier, les noms comme chaînes. Voici à quoi ressemble la HashMap cor­res­pon­dante 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 main­te­nant la HashMap Java, mais elle est encore com­plè­te­ment 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 res­sem­bler à ceci :

{1077=Sabine Berron, 15312=Peter Smith, 73329=Maria Grosso}

Accéder aux éléments

Main­te­nant, nous avons certes créé une liste de clients qui peut théo­ri­que­ment contenir beaucoup plus d’entrées, mais nous voulons aussi pouvoir accéder aux dif­fé­rents clients. Pour cela, nous trans­met­tons 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 ap­pa­raître.

Supprimer une ou toutes les entrées

Si vous souhaitez supprimer une entrée spé­ci­fique, 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 main­te­nant à ceci :

{15312=Peter Smith, 73329=Maria Grosso}

Vous avez également la pos­si­bi­lité de supprimer toute la liste. Pour cela, vous utilisez la méthode clear(). Nous l’ap­pli­quons 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é­ter­mi­ner 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 im­por­tants avec cette classe. Dans notre exemple, il peut être très in­té­res­sant de dé­ter­mi­ner le nombre exact d’entrées dif­fé­rentes. Il s’agirait en fin de compte de l’ensemble de votre base de données clients. La méthode ap­pro­prié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.

Re­pré­sen­ter 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 dis­po­ni­bi­lité 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 con­tains­Key() (pour les clés) et con­tains­Va­lue() (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

682c22c1b0821a9899022c5198775955