HashMap : de quel type de carte s'agit-il ?

Salut! Dans cette leçon, nous examinerons de plus près Java HashMap . Auparavant, nous avons étudié les structures de données où les éléments sont stockés comme eux-mêmes. Dans un tableau ou une ArrayList / LinkedList , nous stockons un certain nombre d'éléments. Mais que se passe-t-il si notre tâche change un peu ? Imaginez la tâche suivante : créez une liste de 100 personnes qui stocke le nom et le numéro de passeport de chaque personne. En principe, ce n'est pas si difficile. Par exemple, vous pouvez insérer les deux dans une chaîne, puis créer une liste de ces chaînes : "Amelia Aguilar, 4211 717171". Mais cette solution présente deux inconvénients. Tout d'abord, nous aurons peut-être besoin de pouvoir effectuer une recherche par numéro de passeport. Et ce sera problématique compte tenu de ce format de stockage des informations. Deuxièmement, rien ne nous empêche de créer deux personnes différentes avec le même numéro de passeport. Et c'est le défaut le plus sérieux de notre solution. Cela ne devrait jamais être autorisé : deux personnes n'ont pas le même numéro de passeport. Une nouvelle structure de données vient à notre secours : Map. Il est également connu sous le nom de "tableau associatif", mais ce terme est rarement utilisé. Plus communément, on l'appelle un "dictionnaire" ou une "carte". :) En quoi est-ce fondamentalement différent des structures de données que nous avons considérées précédemment ? Surtout, dans le fait que les données d'une carte sont stockées sous forme de paires clé-valeur. Tout peut servir de clés et de valeurs : nombres, chaînes ou objets d'autres classes. Aujourd'hui, nous allons étudier l'implémentation la plus courante de la classe Map : Java HashMap .

Alors, que devons-nous savoir sur HashMap en Java ?

Il est très simple de créer :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
}

Ici, nous créons un dictionnaire qui stocke les éléments sous forme de paires "nombre-chaîne". Le nombre agira comme clé et la chaîne comme valeur. Nous spécifions également le type de clé (Integer) et le type de valeur (String). Pourquoi? Premièrement, une clé HashMap est toujours unique. Cela nous convient parfaitement, puisque nous pouvons utiliser le numéro de passeport comme clé et éviter les doublons. La valeur sera une chaîne avec le nom complet (différentes personnes peuvent avoir le même nom, nous n'avons rien à craindre). L'ajout d'une nouvelle paire au HashMap ressemble à ceci :

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");
       System.out.println(passportsAndNames);
   }
}

Nous utilisons pour cela la méthode put() . De plus, HashMap remplace la méthode toString() , afin qu'elle puisse être affichée sur la console. La sortie ressemblera à ceci : {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan le Grand} Vérifions maintenant si les clés sont vraiment uniques ? Essayons d'ajouter un nouvel élément avec une clé qui a déjà été utilisée dans la carte :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");
   passportsAndNames.put(162348, "Albert Kent");// This key has already been used
   System.out.println(passportsAndNames);
}

Sortie : {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Albert Kent} Comme vous pouvez le voir, la valeur précédente associée à la clé 162348 a été écrasée. Nous utilisons le terme "clé" pour une raison. Les valeurs d'un HashMap sont accessibles à l'aide de la clé, mais pas l'inverse. La clé ne peut pas être obtenue à l'aide d'une valeur, car les valeurs peuvent ne pas être uniques. Cela peut être clairement vu lors de l'obtention ou de la suppression d'un élément du HashMap :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   String lidiaName = passportsAndNames.get(212133);
   System.out.println(lidiaName);

   passportsAndNames.remove(162348);
   System.out.println(passportsAndNames);
}

Pour obtenir une valeur ou supprimer une paire du dictionnaire, nous devons passer à get() et remove() la clé unique qui correspond à la valeur. Contrairement aux tableaux et aux listes, un HashMap en Java n'a pas d'indices numériques : les valeurs sont accessibles à l'aide de la clé. Sortie console : Bridget Logan {212133=Bridget Logan, 8082771=Donald John Trump} Les classes ArrayList et LinkedList nous permettent de vérifier si la liste contient un élément particulier. Java HashMap nous permet de faire cela. De plus, nous pouvons le faire pour les deux membres de la paire : c'est ce que containsKey() (vérifie une clé) et containsValue()(vérifie une valeur) les méthodes sont pour.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.containsKey(11111));
   System.out.println(passportsAndNames.containsValue("Donald John Trump"));
}

Sortie : false true Une autre fonctionnalité pratique de HashMap en Java est le fait que vous pouvez obtenir des listes séparées de toutes les clés et de toutes les valeurs. Ceci est accompli avec les méthodes keySet() et values() :

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");

       Set keys = passportsAndNames.keySet();
       System.out.println("Keys: " + keys);

       ArrayList<String> values = new ArrayList<>(passportsAndNames.values());
       System.out.println("Values: " + values);
   }
}

Les clés sont extraites dans un Set , que nous n'avons pas encore couvert. Il est spécial en ce qu'il ne peut pas contenir d'éléments répétitifs. Maintenant, l'essentiel est de se rappeler que la liste de toutes les clés peut être récupérée à partir d'un HashMap dans une collection distincte. Dans l'exemple, nous avons enregistré les valeurs dans un ArrayList ordinaire . Sortie console : Clés : [212133, 8082771, 162348] Valeurs : [Bridget Logan, Donald John Trump, Ivan le Grand] Les méthodes size() et clear() font exactement la même chose que dans les structures précédentes dont nous avons parlé : le premier renvoie le nombre d'éléments actuellement dans le dictionnaire, le second supprime tous les éléments.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.size());
   passportsAndNames.clear();
   System.out.println(passportsAndNames);
}

Sortie : 3 {} Pour vérifier s'il y a au moins un élément dans notre HashMap , nous pouvons utiliser la méthode isEmpty() :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   if (!passportsAndNames.isEmpty()) {

       System.out.println(passportsAndNames);
   }
}

Sortie : {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan le Grand} Maintenant, nous ne sortirons sur la console qu'après une vérification préliminaire. :) Un autre point intéressant est que deux cartes peuvent être combinées en une seule. Ceci est accompli en utilisant la méthode putAll() . Nous l'appelons sur le premier HashMap , passons le second en argument, et les éléments du second sont ajoutés au premier :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
   HashMap<Integer, String> passportsAndNames2 = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   passportsAndNames2.put(917352, "Clifford Patrick");
   passportsAndNames2.put(925648, "Mitchell Salgado");

   passportsAndNames.putAll(passportsAndNames2);
   System.out.println(passportsAndNames);
}

Sortie : {917352=Clifford Patrick, 212133=Bridget Logan, 8082771=Donald John Trump, 925648=Mitchell Salgado, 162348=Ivan le Grand} Toutes les paires de passeportsEtNoms2 ont été copiées dans passeportsEtNoms . Considérons maintenant un exemple plus compliqué. Plus précisément, itérer sur un HashMap dans une boucle.

for (Map.Entry<Integer, String> entry: passportsAndNames.entrySet()) {
   System.out.println(entry);
}

La classe Map.Entry désigne la paire clé-valeur à l'intérieur du dictionnaire. La méthode entrySet() renvoie une liste de toutes les paires dans notre HashMap . Étant donné que notre carte se compose de ces paires Map.Entry , nous itérons sur des paires, et non sur des clés ou des valeurs séparées. Sortie : 212133=Bridget Logan 8082771=Donald John Trump 162348=Ivan le Grand N'oubliez pas non plus d'étudier la documentation officielle d'Oracle pour HashMap .