Java HashMap : Votre clé pour un stockage et une récupération efficaces des données

Introduction

Bonjour à toi, aspirant programmeur Java !aujourd'hui, nous allons embarquer dans un voyage passionnant dans le monde des Java HashMaps. Maintenant, ne laissez pas ce nom pompeux vous effrayer. Pensez à un HashMap comme à un classeur super intelligent pour vos données. C'est comme avoir un assistant personnel qui peut instantanément trouver n'importe quelle information dont vous avez besoin !

Lorsque j'ai appris les HashMaps pour la première fois, je les imaginais comme une bibliothèque magique où les livres (nos données) pourraient s'envoler des étagères et se retrouver dans nos mains au moment où nous les demandons. C'est pratiquement ce que font les HashMaps, mais avec des données informatiques au lieu de livres. Cool, non ?

Plongeons dedans et déverrons les secrets de cette puissante classe Java !

Déclaration de classe

En Java, la classe HashMap est déclarée comme suit :

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

Ouaouh ! C'est un sacré bouchon, n'est-ce pas ? Ne vous inquiétez pas si cela ressemble à une soupe d'alphabet actuellement. Analysons cela :

• public class HashMap<K,V> : Cela nous indique que HashMap est une classe publique (n'importe qui peut l'utiliser) et qu'elle utilise deux paramètres de type, K pour le type de clé et V pour le type de valeur.
• extends AbstractMap<K,V> : HashMap s'élève sur une autre classe appelée AbstractMap.
• implements Map<K,V>, Cloneable, Serializable : Ce sont des interfaces que HashMap implémente, lui conférant des superpouvoirs supplémentaires !

Paramètres

Souvenez-vous de notre analogie de bibliothèque magique ? Eh bien, dans cette bibliothèque, chaque livre (valeur) a un numéro de référence unique (clé). En termes de HashMap :

• K : Le type de clés maintenues par cette carte
• V : Le type de valeurs mappées

Par exemple, si vous vouliez stocker les âges des gens, vous pourriez utiliser String pour les noms (clés) et Integer pour les âges (valeurs).

Constructeurs de classe

Les HashMaps sont livrés avec quatre constructeurs différents. Pensez à ces derniers comme des différentes manières de construire notre bibliothèque magique :

1. HashMap() : Crée un HashMap vide avec une capacité et un facteur de charge par défaut.
2. HashMap(int initialCapacity) : Crée un HashMap vide avec la capacité initiale spécifiée et le facteur de charge par défaut.
3. HashMap(int initialCapacity, float loadFactor) : Crée un HashMap vide avec la capacité initiale et le facteur de charge spécifiés.
4. HashMap(Map<? extends K, ? extends V> m) : Crée un nouveau HashMap avec les mêmes mappages que la Map spécifiée.

Ne vous inquiétez pas trop de la capacité et du facteur de charge pour le moment. Sachez simplement qu'ils affectent la manière dont notre HashMap fonctionne en arrière-plan.

Méthodes de classe

Maintenant, examinons certaines des choses impressionnantes que notre HashMap peut faire. Voici les méthodes les plus couramment utilisées :

Méthode	Description
put(K key, V value)	Ajoute une paire clé-valeur à la carte
get(Object key)	Récupère la valeur associée à la clé spécifiée
remove(Object key)	Supprime le mappage pour la clé spécifiée
clear()	Supprime tous les mappages de la carte
size()	Retourne le nombre de mappages clé-valeur dans la carte
isEmpty()	Retourne vrai si la carte ne contient aucun mappage
containsKey(Object key)	Retourne vrai si la carte contient la clé spécifiée
containsValue(Object value)	Retourne vrai si la carte contient la valeur spécifiée

Méthodes héritées

HashMap hérite également de méthodes de ses classes parentes et d'interfaces. C'est comme si notre bibliothèque magique avait hérité quelques tours de force de bibliothèques plus anciennes et plus sages ! Voici quelques exemples :

• De java.util.AbstractMap : equals(), hashCode(), toString()
• De java.util.Map : putAll(), entrySet(), keySet(), values()

Exemple

Mettons en pratique nos connaissances nouvellement acquises avec un exemple simple. Nous allons créer un HashMap pour stocker les âges de quelques scientifiques célèbres :

import java.util.HashMap;

public class ScientistAges {
public static void main(String[] args) {
// Crée un nouveau HashMap
HashMap<String, Integer> scientistAges = new HashMap<>();

// Ajoutez quelques paires clé-valeur
scientistAges.put("Albert Einstein", 76);
scientistAges.put("Isaac Newton", 84);
scientistAges.put("Marie Curie", 66);

// Récupère et imprime une valeur
System.out.println("Age d'Albert Einstein : " + scientistAges.get("Albert Einstein"));

// Vérifiez si une clé existe
if (scientistAges.containsKey("Stephen Hawking")) {
System.out.println("Nous avons l'âge de Stephen Hawking.");
} else {
System.out.println("Nous n'avons pas l'âge de Stephen Hawking.");
}

// Imprimez la taille du HashMap
System.out.println("Nombre de scientifiques : " + scientistAges.size());

// Supprimez une paire clé-valeur
scientistAges.remove("Isaac Newton");

// Imprimez toutes les paires clé-valeur
for (String name : scientistAges.keySet()) {
System.out.println(name + " a vécu jusqu'à " + scientistAges.get(name) + " ans.");
}
}
}

Sortie

Lorsque nous exécutons ce code, voici ce que nous verrons :

Age d'Albert Einstein : 76
Nous n'avons pas l'âge de Stephen Hawking.
Nombre de scientifiques : 3
Albert Einstein a vécu jusqu'à 76 ans.
Marie Curie a vécu jusqu'à 66 ans.

Décomposons ce qui s'est passé :

1. Nous avons créé un nouveau HashMap appelé scientistAges.
2. Nous avons ajouté trois paires clé-valeur : les noms des scientifiques et leurs âges.
3. Nous avons récupéré l'âge d'Einstein à l'aide de la méthode get().
4. Nous avons vérifié si nous avions l'âge de Hawking en utilisant containsKey(). Nous ne l'avions pas, donc il a imprimé le message "nous n'avons pas".
5. Nous avons imprimé le nombre de scientifiques dans notre carte en utilisant size().
6. Nous avons supprimé Newton de la carte en utilisant remove().
7. Enfin, nous avons utilisé une boucle for-each pour itérer sur toutes les paires clé-valeur restantes et les imprimer.

Et voilà ! Vous avez juste pris vos premiers pas dans le monde des Java HashMaps. Souvenez-vous, la pratique fait le maître. Essayez de créer vos propres HashMaps avec différents types de données. Peut-être faire une carte de vos livres préférés et de leurs auteurs, ou de vos amis et de leurs numéros de téléphone.

Les HashMaps sont incroyablement utiles dans la programmation réelle. Ils sont comme le couteau suisse des structures de données - polyvalent, efficace et toujours utile à avoir à portée de main. Continuez à explorer, à coder, et avant que vous ne le sachiez, vous serez un maître des HashMaps !

Credits: Image by storyset