L’interface Map en Java

• Map n’étend pas l’interface Collection, car elle ne stocke pas directement des éléments individuels, mais plutôt des paires clé-valeur. Nous pouvons d’ailleurs constater que les méthodes de l’interface Map ne sont pas les mêmes que celles de l’interface Collection. Les clés d’une Map sont uniques, c’est-à-dire qu’il ne peut pas y avoir de doublons dans les clés. Par ailleurs, les valeurs d’une Map peuvent être en double, c’est-à-dire qu’il peut y avoir plusieurs paires avec la même valeur.

Une Map représente une relation binaire surjective : chaque élément d’une Map est une paire qui met en relation une une clé à une valeur : chaque clé est unique, mais on peut avoir des doublons pour les valeurs.

1. put(K key, V value) : ajoute une paire clé-valeur à la Map ou remplace la valeur associée à la clé donnée..

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        // Ajout de paires clé-valeur
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        // Affichage de la map
        System.out.println("Map après ajout : " + map);

        // Remplacement de la valeur associée à "Banana"
        map.put("Banana", 4);
        System.out.println("Map après remplacement : " + map);
    }
}

2. get(Object key) : renvoie la valeur associée à la clé donnée, ou null si la clé n’est pas présente dans la Map.

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);
        
        // Récupération des valeurs associées aux clés
        Integer appleValue = map.get("Apple");
        Integer bananaValue = map.get("Banana");
        Integer mangoValue = map.get("Mango"); // Clé inexistante
        
        System.out.println("Valeur associée à 'Apple' : " + appleValue);
        System.out.println("Valeur associée à 'Banana' : " + bananaValue);
        System.out.println("Valeur associée à 'Mango' : " + mangoValue); // Devrait afficher null
    }
}

3. remove(Object key) : supprime la paire clé-valeur associée à la clé donnée.

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);
        
        // Suppression de la paire clé-valeur associée à "Banana"
        map.remove("Banana");
        
        System.out.println("Map après suppression : " + map);
    }
}

4. containsKey(Object key) : vérifie si la clé donnée est présente dans la Map.

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);
        
        // Vérification de la présence des clés
        boolean containsApple = map.containsKey("Apple");
        boolean containsMango = map.containsKey("Mango");
        
        System.out.println("La clé 'Apple' est présente : " + containsApple);
        System.out.println("La clé 'Mango' est présente : " + containsMango);
    }
}

5. keySet() : renvoie un ensemble des clés présentes dans la Map.

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);
        
        // Récupération de l'ensemble des clés
        Set<String> keys = map.keySet();
        
        System.out.println("Clés présentes dans la Map : " + keys);
    }
}

1. HashMap

• Description : HashMap est basé sur une table de hachage. Il offre une performance pour les opérations de base (ajout, suppression, recherche) dans la plupart des cas./li>
• Caractéristiques :
• Non ordonné : Les éléments ne sont pas stockés dans un ordre particulier.
• Permet les clés null et les valeurs null.
• Rapide pour les opérations de base.
• Exemple :

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

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        
        // Ajout de paires clé-valeur
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        // Affichage de la map
        System.out.println("HashMap: " + map);
        
        // Accès à une valeur
        System.out.println("Valeur associée à 'Banana': " + map.get("Banana"));
        
        // Suppression d'une paire clé-valeur
        map.remove("Banana");
        System.out.println("HashMap après suppression: " + map);
        
        // Vérification de la présence d'une clé
        System.out.println("La clé 'Apple' est présente: " + map.containsKey("Apple"));
        
        // Affichage de l'ensemble des clés
        System.out.println("Clés présentes dans la HashMap: " + map.keySet());
    }
}

2. LinkedHashMap

• Description : LinkedHashMap est une sous-classe de HashMap qui maintient une liste doublement chaînée de ses entrées. Il conserve l’ordre d’insertion ou l’ordre d’accès si configuré.
• Caractéristiques :
• Ordonné : Maintient l’ordre d’insertion des éléments.
• Permet les clés null et les valeurs null.
• Un peu plus lent que HashMap en raison de la gestion de la liste chaînée.
• Exemple :

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<>();
        
        // Ajout de paires clé-valeur
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        // Affichage de la map
        System.out.println("LinkedHashMap: " + map);
        
        // Accès à une valeur
        System.out.println("Valeur associée à 'Banana': " + map.get("Banana"));
        
        // Suppression d'une paire clé-valeur
        map.remove("Banana");
        System.out.println("LinkedHashMap après suppression: " + map);
        
        // Vérification de la présence d'une clé
        System.out.println("La clé 'Apple' est présente: " + map.containsKey("Apple"));
        
        // Affichage de l'ensemble des clés
        System.out.println("Clés présentes dans la LinkedHashMap: " + map.keySet());
    }
}

3. TreeMap

• Description : TreeMap est basé sur une structure d’arbre de recherche binaire (Red-Black Tree). Il garantit que les éléments sont stockés dans un ordre trié.
• Caractéristiques :
• Trié : Maintient les éléments dans un ordre naturel (ou un ordre personnalisé défini par un Comparator).
• Plus lent que HashMap pour les opérations de base avec une complexité O(log n).
• Ne permet pas les clés null.
• Exemple :

import java.util.Map;
import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();
        
        // Ajout de paires clé-valeur
        map.put("Apple", 1);
        map.put("Banana", 2);
        map.put("Cherry", 3);

        // Affichage de la map
        System.out.println("TreeMap: " + map);
        
        // Accès à une valeur
        System.out.println("Valeur associée à 'Banana': " + map.get("Banana"));
        
        // Suppression d'une paire clé-valeur
        map.remove("Banana");
        System.out.println("TreeMap après suppression: " + map);
        
        // Vérification de la présence d'une clé
        System.out.println("La clé 'Apple' est présente: " + map.containsKey("Apple"));
        
        // Affichage de l'ensemble des clés
        System.out.println("Clés présentes dans la TreeMap: " + map.keySet());
    }
}

4. Comparaison des Implémentations de Map

Implémentation	Ordre des Éléments	Complexité Moyenne des Opérations de Base	Caractéristiques Spéciales
HashMap	Non ordonné	O(1)	Rapide, mais sans ordre particulier
LinkedHashMap	Ordre d’insertion	O(1)	Maintient l’ordre d’insertion des éléments
TreeMap	Ordre naturel ou défini	O(log n)	Trie les éléments, plus lent

5. Exercice Pratique: Comparaison des Implémentations de Map

• Comparer le comportement des différentes implémentations de Map (HashMap, LinkedHashMap, TreeMap) en ajoutant, supprimant et recherchant des paires clé-valeur.
• Ajoutez les mêmes paires clé-valeur dans chaque Map.
• Supprimez certaines paires clé-valeur.
• Vérifiez la présence de certaines clés.
• Affichez les Map pour observer l’ordre des éléments.
Code

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapComparisonExample {
    public static void main(String[] args) {
        // Création des trois implémentations de Map
        Map<String, Integer> hashMap = new HashMap<>();
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        Map<String, Integer> treeMap = new TreeMap<>();

        // Ajout des mêmes paires clé-valeur dans chaque Map
        String[] keys = {"Banana", "Apple", "Cherry", "Date"};
        int[] values = {2, 1, 3, 4};

        for (int i = 0; i < keys.length; i++) {
            hashMap.put(keys[i], values[i]);
            linkedHashMap.put(keys[i], values[i]);
            treeMap.put(keys[i], values[i]);
        }

        // Affichage des Map après ajout des éléments
        System.out.println("HashMap après ajout : " + hashMap);
        System.out.println("LinkedHashMap après ajout : " + linkedHashMap);
        System.out.println("TreeMap après ajout : " + treeMap);

        // Suppression de certaines paires clé-valeur
        hashMap.remove("Banana");
        linkedHashMap.remove("Banana");
        treeMap.remove("Banana");

        // Affichage des Map après suppression des éléments
        System.out.println("HashMap après suppression : " + hashMap);
        System.out.println("LinkedHashMap après suppression : " + linkedHashMap);
        System.out.println("TreeMap après suppression : " + treeMap);

        // Vérification de la présence de certaines clés
        System.out.println("HashMap contient 'Apple' : " + hashMap.containsKey("Apple"));
        System.out.println("LinkedHashMap contient 'Apple' : " + linkedHashMap.containsKey("Apple"));
        System.out.println("TreeMap contient 'Apple' : " + treeMap.containsKey("Apple"));

        System.out.println("HashMap contient 'Banana' : " + hashMap.containsKey("Banana"));
        System.out.println("LinkedHashMap contient 'Banana' : " + linkedHashMap.containsKey("Banana"));
        System.out.println("TreeMap contient 'Banana' : " + treeMap.containsKey("Banana"));

        // Affichage des ensembles de clés
        System.out.println("Clés présentes dans HashMap : " + hashMap.keySet());
        System.out.println("Clés présentes dans LinkedHashMap : " + linkedHashMap.keySet());
        System.out.println("Clés présentes dans TreeMap : " + treeMap.keySet());
    }
}

6. En exécutant ce code, vous pourrez observer les différences de comportement entre HashMap, LinkedHashMap, et TreeMap. Vous verrez que :
• HashMap n'a pas d'ordre particulier.
• LinkedHashMap maintient l'ordre d'insertion.
• TreeMap maintient les éléments triés par clé.
7. Ce type d'exercice permet de comprendre les avantages et les inconvénients de chaque implémentation de Map et de choisir celle qui convient le mieux à vos besoins spécifiques.