L’interface Map en Java
Sommaire
- 1- Objectifs
- 2- Introduction :
- 3- L’interface Map
- 4- Méthodes de l’interface Map
- 4.1-
put(K key, V value)
: ajoute une paire clé-valeur à la Map ou remplace la valeur associée à la clé donnée.. - 4.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. - 4.3-
remove(Object key)
: supprime la paire clé-valeur associée à la clé donnée. - 4.4-
containsKey(Object key)
: vérifie si la clé donnée est présente dans la Map. - 4.5-
keySet()
: renvoie un ensemble des clés présentes dans la Map. - 5- Les implémentations de Map
- 5.1-
HashMap
- 5.2-
LinkedHashMap
- 5.3-
TreeMap
- 5.4- Comparaison des Implémentations de Map
- 5.5- Exercice Pratique: Comparaison des Implémentations de Map
- 6- Applications
- 6.1- Exercice 1 : Ajout de Paires Clé-Valeur à une Map et Affichage dans une ListView
- 6.2- Exercice 2 : Suppression d'Éléments d'une Map via une Interface JavaFX
- 6.3- Exercice 3 : Vérification de la Présence d'une Clé dans une Map via une Interface JavaFX
- 6.3.1- Cours JAVA
L’interface Map en Java
-
Objectifs
- Comprendre ce qu’est une interface en Java.
- Expliquer le rôle et l’importance de l’interface Map dans la Collection Framework.
-
Introduction :
- L’API Collections propose un ensemble d’interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections, chacune définie par une interface de base :
- List : collection d’éléments ordonnés qui accepte les doublons
- Set : collection d’éléments non ordonnés par défaut qui n’accepte pas les doublons
Map
: collection sous la forme d’une association de paires clé/valeur- Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu’ils ne soient extraits pour traitement
-
L’interface Map
- L’interface Map en Java est une interface de la bibliothèque standard qui permet de stocker des paires clé-valeur et de manipuler ces paires. Voici quelques informations importantes à connaître sur cette interface.
- 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.
-
Méthodes de l’interface Map
- Voici quelques-unes des méthodes les plus couramment utilisées de l’interface Map:
-
put(K key, V value)
: ajoute une paire clé-valeur à la Map ou remplace la valeur associée à la clé donnée.. -
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. -
remove(Object key)
: supprime la paire clé-valeur associée à la clé donnée. -
containsKey(Object key)
: vérifie si la clé donnée est présente dans la Map. -
keySet()
: renvoie un ensemble des clés présentes dans la Map. -
Les implémentations de Map
- En effet, Map est une interface en Java, et elle ne peut pas être instanciée directement. Pour utiliser une Map, vous devez choisir une implémentation concrète comme
HashMap
,TreeMap
, ouLinkedHashMap
. - Chaque implémentation a ses propres caractéristiques et avantages en fonction des besoins spécifiques de votre application. Voici un aperçu des implémentations courantes de l’interface Map, avec des exemples d’utilisation pour chacune.
-
HashMap
- Description : HashMap est basé sur une table de hachage. Il offre une performance O(1) 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 :
-
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 :
-
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 :
-
Comparaison des Implémentations de Map
-
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.
- 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é.- 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.
-
Applications
-
Exercice 1 : Ajout de Paires Clé-Valeur à une Map et Affichage dans une ListView
- Créer une interface JavaFX qui permet à l'utilisateur d'ajouter des paires clé-valeur à une Map et d'afficher ces paires dans une ListView.
- Créez une application JavaFX de base.
- Ajouter deux champs de texte (un pour la clé, un pour la valeur) et un bouton pour ajouter des paires clé-valeur à une Map
- Utiliser une Map pour stocker les paires clé-valeur ajoutées.
- Afficher les paires clé-valeur de la Map dans une ListView.
-
Exercice 2 : Suppression d'Éléments d'une Map via une Interface JavaFX
- Ajouter la fonctionnalité permettant de supprimer des paires clé-valeur d'une Map via une interface JavaFX.
- Étendre l'application précédente.
- Ajouter un bouton pour supprimer l'élément sélectionné dans la ListView.
- Mettre à jour la Map et la ListView en conséquence.
-
Exercice 3 : Vérification de la Présence d'une Clé dans une Map via une Interface JavaFX
- Ajouter une fonctionnalité permettant de vérifier si une clé existe dans la Map via l'interface JavaFX.
- Étendre l'application précédente.
- Ajouter un champ de texte et un bouton pour vérifier la présence d'une clé dans la Map.
- Afficher un message indiquant si la clé existe ou non.
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map 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);
}
}
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map 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
}
}
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map 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);
}
}
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
Map 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);
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
Map 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 keys = map.keySet();
System.out.println("Clés présentes dans la Map : " + keys);
}
}
import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
public static void main(String[] args) {
Map 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());
}
}
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapExample {
public static void main(String[] args) {
Map 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());
}
}
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
Map 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());
}
}
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 |
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 hashMap = new HashMap<>();
Map linkedHashMap = new LinkedHashMap<>();
Map 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());
}
}
Code
package application;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashMap;
import java.util.Map;
public class InterfaceMap extends Application {
private Map map = new HashMap<>();
private ListView listView = new ListView<>();
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
// Création des éléments de l'interface utilisateur
TextField keyField = new TextField();
keyField.setPromptText("Clé");
TextField valueField = new TextField();
valueField.setPromptText("Valeur");
Button addButton = new Button("Ajouter");
// Ajout de la paire clé-valeur à la Map et mise à jour de la ListView
addButton.setOnAction(e -> {
String key = keyField.getText();
String value = valueField.getText();
if (key.isEmpty() || value.isEmpty()) {
Alert alert = new Alert(Alert.AlertType.WARNING, "La clé et la valeur doivent être non vides!");
alert.showAndWait();
return;
}
map.put(key, value);
updateListView();
keyField.clear();
valueField.clear();
});
// Disposition des éléments dans la fenêtre
VBox vbox = new VBox(10, keyField, valueField, addButton, listView);
Scene scene = new Scene(vbox, 300, 400);
primaryStage.setTitle("Map Example");
primaryStage.setScene(scene);
primaryStage.show();
}
// Mise à jour de la ListView avec les paires clé-valeur de la Map
private void updateListView() {
listView.getItems().clear();
for (Map.Entry entry : map.entrySet()) {
listView.getItems().add(entry.getKey() + " : " + entry.getValue());
}
}
}
Code
package application;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashMap;
import java.util.Map;
public class InterfaceMap extends Application {
private Map map = new HashMap<>();
private ListView listView = new ListView<>();
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
// Création des éléments de l'interface utilisateur
TextField keyField = new TextField();
keyField.setPromptText("Clé");
TextField valueField = new TextField();
valueField.setPromptText("Valeur");
Button addButton = new Button("Ajouter");
Button removeButton = new Button("Supprimer Sélection");
// Ajout de la paire clé-valeur à la Map et mise à jour de la ListView
addButton.setOnAction(e -> {
String key = keyField.getText();
String value = valueField.getText();
if (key.isEmpty() || value.isEmpty()) {
Alert alert = new Alert(Alert.AlertType.WARNING, "La clé et la valeur doivent être non vides!");
alert.showAndWait();
return;
}
map.put(key, value);
updateListView();
keyField.clear();
valueField.clear();
});
// Suppression de l'élément sélectionné dans la ListView
removeButton.setOnAction(e -> {
String selectedItem = listView.getSelectionModel().getSelectedItem();
if (selectedItem != null) {
String keyToRemove = selectedItem.split(" : ")[0];
map.remove(keyToRemove);
updateListView();
} else {
Alert alert = new Alert(Alert.AlertType.WARNING, "Aucun élément sélectionné !");
alert.showAndWait();
}
});
// Disposition des éléments dans la fenêtre
VBox vbox = new VBox(10, keyField, valueField, addButton, removeButton, listView);
Scene scene = new Scene(vbox, 300, 400);
primaryStage.setTitle("Map Example");
primaryStage.setScene(scene);
primaryStage.show();
}
// Mise à jour de la ListView avec les paires clé-valeur de la Map
private void updateListView() {
listView.getItems().clear();
for (Map.Entry entry : map.entrySet()) {
listView.getItems().add(entry.getKey() + " : " + entry.getValue());
}
}
}
Code
package application;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.HashMap;
import java.util.Map;
public class InterfaceMap extends Application {
private Map map = new HashMap<>();
private ListView listView = new ListView<>();
public static void main(String[] args) {
launch(args);
}
@Override
public void start(Stage primaryStage) {
// Création des éléments de l'interface utilisateur
TextField keyField = new TextField();
keyField.setPromptText("Clé");
TextField valueField = new TextField();
valueField.setPromptText("Valeur");
Button addButton = new Button("Ajouter");
Button removeButton = new Button("Supprimer Sélection");
TextField checkField = new TextField();
checkField.setPromptText("Vérifier Clé");
Button checkButton = new Button("Vérifier");
// Ajout de la paire clé-valeur à la Map et mise à jour de la ListView
addButton.setOnAction(e -> {
String key = keyField.getText();
String value = valueField.getText();
if (key.isEmpty() || value.isEmpty()) {
Alert alert = new Alert(Alert.AlertType.WARNING, "La clé et la valeur doivent être non vides!");
alert.showAndWait();
return;
}
map.put(key, value);
updateListView();
keyField.clear();
valueField.clear();
});
// Suppression de l'élément sélectionné dans la ListView
removeButton.setOnAction(e -> {
String selectedItem = listView.getSelectionModel().getSelectedItem();
if (selectedItem != null) {
String keyToRemove = selectedItem.split(" : ")[0];
map.remove(keyToRemove);
updateListView();
} else {
Alert alert = new Alert(Alert.AlertType.WARNING, "Aucun élément sélectionné !");
alert.showAndWait();
}
});
// Vérification de la présence d'une clé dans la Map
checkButton.setOnAction(e -> {
String keyToCheck = checkField.getText();
if (keyToCheck.isEmpty()) {
Alert alert = new Alert(Alert.AlertType.WARNING, "La clé à vérifier doit être non vide!");
alert.showAndWait();
return;
}
if (map.containsKey(keyToCheck)) {
Alert alert = new Alert(Alert.AlertType.INFORMATION, "La clé '" + keyToCheck + "' existe dans la Map.");
alert.showAndWait();
} else {
Alert alert = new Alert(Alert.AlertType.INFORMATION, "La clé '" + keyToCheck + "' n'existe pas dans la Map.");
alert.showAndWait();
}
checkField.clear();
});
// Disposition des éléments dans la fenêtre
VBox vbox = new VBox(10, keyField, valueField, addButton, removeButton, checkField, checkButton, listView);
Scene scene = new Scene(vbox, 300, 450);
primaryStage.setTitle("Map Example");
primaryStage.setScene(scene);
primaryStage.show();
}
// Mise à jour de la ListView avec les paires clé-valeur de la Map
private void updateListView() {
listView.getItems().clear();
for (Map.Entry entry : map.entrySet()) {
listView.getItems().add(entry.getKey() + " : " + entry.getValue());
}
}
}