Tableaux Java Programmation orientée objet en Java Traitement des fichiers en Java Introduction To Java Les bases du langage Java Mots-clés Java

Java HashMap

En Java, un site HashMap est une partie du Java Collections Framework qui met en œuvre l'interface Map. Il est utilisé pour stocker des paires clé-valeur et offre des performances en temps constant pour les opérations de base telles que l'ajout, la suppression et l'extraction d'éléments. HashMap est très efficace et est couramment utilisé lorsque l'association unique de clés à des valeurs est requise.

Caractéristiques principales

Collection non ordonnée: HashMap ne maintient aucun ordre pour ses entrées.
Autorise les valeurs nulles: Il autorise une clé nulle et plusieurs valeurs nulles.
Non synchronisé: HashMap n'est pas sûr pour les threads. Pour un accès simultané, envisagez d'utiliser ConcurrentHashMap.

Utilisation

HashMap est idéal pour les scénarios dans lesquels la recherche, l'insertion et la suppression rapides d'éléments sont nécessaires. Il est souvent utilisé pour la mise en cache des données, la gestion des sessions utilisateur et la mise en œuvre de dictionnaires.

Syntax

HashMap<KeyType, ValueType> mapName = new HashMap<>();Propulsé par

KeyType: Le type de données des clés.
ValueType: Le type de données des valeurs.
mapName: Le nom de l'instance HashMap.

Exemples

Exemple 1 : Opérations de base

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        
        // Adding elements
        map.put("Apple", 3);
        map.put("Banana", 5);
        map.put("Orange", 2);
        
        // Retrieving an element
        int count = map.get("Apple");
        System.out.println("Count of Apples: " + count);
        
        // Removing an element
        map.remove("Banana");
        
        // Checking if a key exists
        boolean hasOrange = map.containsKey("Orange");
        System.out.println("Contains Orange: " + hasOrange);
    }
}Propulsé par

Cet exemple démontre les opérations de base avec un HashMap, notamment l'ajout, l'extraction et la suppression d'éléments, ainsi que la vérification de l'existence d'une clé.

Exemple 2 : Itérer sur une table de hachage

import java.util.HashMap;
import java.util.Map;

public class HashMapIteration {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Dog", 1);
        map.put("Cat", 2);
        map.put("Bird", 3);
        
        // Iterating using entrySet
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}Propulsé par

Cet exemple montre comment parcourir un site HashMap à l'aide de la méthode entrySet, qui permet d'accéder à la fois aux clés et aux valeurs.

Exemple 3 : Travailler avec différents types de données

import java.util.HashMap;

public class HashMapDifferentTypes {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        
        System.out.println("Value for key 1: " + map.get(1));
    }
}Propulsé par

Cet exemple montre un HashMap avec des clés Integer et des valeurs String.

Conseils et bonnes pratiques

Capacité initiale et facteur de charge : Lors de la création d'un site HashMap, pensez à spécifier une capacité initiale et un facteur de charge afin d'optimiser les performances et de réduire le nombre d'opérations de rehash.
```
HashMap map = new HashMap<>(16, 0.75f);Propulsé par
```
Évitez les redimensionnements fréquents: Si la taille du site HashMap est connue à l'avance, définissez une capacité initiale appropriée afin d'éviter les redimensionnements fréquents, qui peuvent dégrader les performances.
Sécurité du fil: Si plusieurs threads sont censés accéder simultanément à HashMap, utilisez Collections.synchronizedMap ou ConcurrentHashMap pour garantir la sécurité des threads.
Utilisez des clés immuables: Préférez l'utilisation d'objets immuables comme clés pour éviter les problèmes de cohérence du code de hachage et les comportements inattendus.
Traitement des nullités: Soyez prudent lorsque vous utilisez des clés ou des valeurs nulles et veillez à ce que votre logique d'application en tienne compte.

Java Documentation