Glissez pour afficher le menu

Nous allons aborder l'interface Map en Java. L'interface Map fait partie du framework Java Collections et définit des méthodes pour manipuler des données sous forme de paires clé-valeur.

Examinons la définition :

La principale implémentation de cette structure de données en Java est HashMap, qui implémente l'interface Map. Examinons les méthodes principales et les principes de fonctionnement de cette implémentation.

Commençons par la déclaration et les méthodes :

Main.java


              1
            
Map<K, V> map = new HashMap<>();

Ici, vous voyez que dans les génériques ou crochets diamant, deux valeurs sont spécifiées :

La valeur K correspond au type de données de la clé ;
La valeur V correspond au type de données de la valeur.

Ainsi, lors de la déclaration de cette structure de données, nous indiquons les types de données de nos paires clé-valeur.

Examinons maintenant les méthodes définies dans l’interface Map.

Méthodes

V put(K key, V value) : associe la valeur spécifiée à la clé spécifiée dans ce Map. Si le Map contenait déjà une association pour cette clé, l’ancienne valeur est remplacée.

Main.java


              1234567891011121314
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key) : renvoie la valeur à laquelle la clé spécifiée est associée, ou null si cette Map ne contient aucune association pour la clé.

C'est ici que l'on spécifie la clé afin d'obtenir la valeur correspondante.

Exemple de récupération de la valeur avec la clé 2 :

Main.java


              12345678910111213141516
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

boolean containsKey(Object key) : renvoie true si la Map contient une association pour la clé spécifiée ;
boolean containsValue(Object value) : renvoie true si la Map contient une ou plusieurs clés associées à la valeur spécifiée.

Ces deux méthodes sont évidemment liées et permettent de déterminer si la Map spécifiée contient les clés ou valeurs recherchées. Ces méthodes sont pratiques à utiliser comme conditions puisqu'elles renvoient des valeurs boolean.

Examinons un exemple :

Main.java


              12345678910111213141516171819202122232425
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

Dans l'exemple ci-dessus, nous vérifions la présence d'une clé et la présence d'une valeur dans le Map. Si des valeurs sont trouvées, nous les affichons dans la console. S'il n'y a pas de telles valeurs, nous affichons des messages indiquant l'absence de ces données.

boolean isEmpty(): retourne true si ce Map ne contient aucune association clé-valeur ;
V remove(Object key): supprime l'association pour la clé spécifiée de ce Map si elle est présente et retourne la valeur précédente.

Comme dans d'autres structures de données, il est possible de supprimer des éléments du Map.

Main.java


              12345678910111213141516
            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Ainsi, il est possible de supprimer des éléments par clé.

Méthodes de base pour la gestion des Maps

Ensuite, voici des méthodes déjà connues, qui seront listées sans exemples. Cependant, il reste également des méthodes intéressantes.

Commençons par les bases :

void clear(): supprime tous les éléments du Map ;
int size(): retourne le nombre d’associations clé-valeur dans ce Map ;
void putAll(Map<? extends K, ? extends V> m): copie toutes les associations du Map spécifié dans ce Map.

Passons maintenant aux méthodes qui retournent une collection de valeurs (ou de clés) issues du Map. Autrement dit, il est possible de récupérer depuis la structure de données une structure clé-valeur qui ne contient que les valeurs (ou les clés). Par exemple, ArrayList<>.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Ici, une collection de valeurs a été obtenue à partir du Map. Il est désormais possible de transférer cette collection dans un ArrayList :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Nous avons initialisé une ArrayList en utilisant les valeurs provenant de la Map.

Il existe également une méthode qui retourne les clés de la Map. Cependant, ces clés seront retournées sous la forme d'une structure appelée Set. Nous n'aborderons pas cette structure de données pour l'instant ; il est important de noter qu'un Set est une structure de données qui contient uniquement des valeurs uniques.

Examinons cette méthode :

Set<K> keySet(): retourne une vue Set des clés contenues dans cette Map.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Ainsi, il est également possible d'obtenir un ensemble de toutes les clés à partir de la Map.

Nous avons donc terminé avec les méthodes. Examinons maintenant l'utilisation de la Map, ainsi que des exemples pratiques :

Utilisation de Map

Une structure de type clé-valeur présente de nombreuses applications pratiques. Considérons la plus simple de ces structures : un système de notation des étudiants.

Créons une Map où la clé est de type String, représentant le nom de l'étudiant, et la valeur est de type Integer, représentant la note de l'étudiant. De cette manière, il est possible d'attribuer des notes aux étudiants et de récupérer facilement la note d'un étudiant spécifique à l'aide de la clé :

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Imaginons maintenant que nous devons récupérer les notes de Mike et Alice, puis les comparer. Vous pouvez facilement réaliser cela en utilisant les méthodes que vous avez apprises ci-dessus. Implémentons cela dans le code :

Main.java


              123456789101112131415161718192021
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

L’opérateur ternaire et la méthode compareTo() de la classe enveloppe Integer ont été utilisés. Si vous ne comprenez pas comment cela fonctionne, voici une explication :

Main.java


              12345678910111213141516171819202122232425
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Considérons maintenant le cas où il est demandé de rassembler tous les étudiants ayant une note supérieure à 7 (excluant 7). Cela devient intéressant, et je vais maintenant vous expliquer comment procéder !

Itération à travers la Map

L'itération sur les éléments d'une Map en Java peut s'effectuer en utilisant différentes méthodes fournies par l'interface Map et ses implémentations. Voici plusieurs façons d'itérer sur une Map :

Itération sur les clés (keySet()) : la méthode keySet() retourne un ensemble de toutes les clés dans la Map. Cet ensemble peut être utilisé pour parcourir les clés et récupérer les valeurs correspondantes.

Main.java


              12345678910111213141516
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Itération sur les valeurs (values()): la méthode values() renvoie une collection de toutes les valeurs dans la Map. Cette collection peut être utilisée pour parcourir les valeurs.

Main.java


              123456789101112131415
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Itération sur les paires clé-valeur (entrySet()) : la méthode entrySet() retourne un ensemble d'objets Map.Entry représentant les paires clé-valeur. Cela permet d'itérer directement sur les paires.

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Approfondissons un peu ce point. Au départ, cela peut sembler extrêmement complexe à comprendre, mais il n'est pas nécessaire de s'attarder sur les détails de son fonctionnement, car la syntaxe reste toujours la même.

Map.Entry<K, V> entry : map.entrySet()

En utilisant l'objet entry, il est possible d'accéder simultanément à la clé et à la valeur dans la Map. À présent, résolvons la tâche évoquée précédemment en utilisant l'ensemble des entrées : récupérer tous les étudiants ayant une note supérieure à 7. Pour cela, un contrôle via entry.getValue() sera utilisé et, lorsqu'un étudiant correspondant est trouvé, sa clé sera ajoutée dans un ArrayList préalablement créé :

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Ainsi, il est possible d’itérer sur la Map et de trouver la liste souhaitée d’étudiants ayant réussi l’examen !

L’ensemble des entrées constitue un outil très utile car il permet différentes méthodes d’itération sur la Map à l’aide d’une boucle, tout en donnant accès à la fois à la clé et à la valeur.

Dans le prochain chapitre, nous approfondirons le fonctionnement de HashMap, que nous avons utilisé de manière intensive dans ce chapitre !

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 13

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 1. Chapitre 13

Qu'est-ce qu'une Map ?

Méthodes

Méthodes de base pour la gestion des Maps

Utilisation de Map

Itération à travers la Map

1. Quelle interface en Java représente une collection de paires clé-valeur ?

2. Comment itérer sur toutes les clés d'une `Map` en utilisant une boucle for-each ?

3. Quel est le but de la méthode `values()` dans une `Map` ?

4. Quelle méthode est utilisée pour vérifier si une clé spécifique est présente dans une `Map` ?

5. Quelle méthode est utilisée pour supprimer une paire clé-valeur d'une `Map` en Java ?

Qu'est-ce qu'une Map ?

Méthodes

Méthodes de base pour la gestion des Maps

Utilisation de Map

Itération à travers la Map

1. Quelle interface en Java représente une collection de paires clé-valeur ?

2. Comment itérer sur toutes les clés d'une Map en utilisant une boucle for-each ?

3. Quel est le but de la méthode values() dans une Map ?

4. Quelle méthode est utilisée pour vérifier si une clé spécifique est présente dans une Map ?

5. Quelle méthode est utilisée pour supprimer une paire clé-valeur d'une Map en Java ?

2. Comment itérer sur toutes les clés d'une `Map` en utilisant une boucle for-each ?

3. Quel est le but de la méthode `values()` dans une `Map` ?

4. Quelle méthode est utilisée pour vérifier si une clé spécifique est présente dans une `Map` ?

5. Quelle méthode est utilisée pour supprimer une paire clé-valeur d'une `Map` en Java ?