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. Explorons 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 chevrons, 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 correspondance pour la 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 liées et permettent de déterminer si la Map 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, la présence d'une clé et la présence d'une valeur dans la Map sont vérifiées. Si les valeurs sont trouvées, elles sont affichées sur la console. En cas d'absence de telles valeurs, des messages indiquant l'absence de ces données sont affichés.

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

Comme pour d'autres structures de données, il est possible de supprimer des éléments de la 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, nous pouvons supprimer des éléments par clé.

Méthodes de base pour la gestion des Maps

Ensuite, il existe des méthodes que vous connaissez déjà, que je vais énumérer sans exemples. Mais il reste aussi des méthodes intéressantes.

Commençons par les bases :

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

Passons maintenant aux méthodes qui retournent une collection avec les valeurs (ou les clés) de la Map. En d’autres termes, nous récupérons 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, nous avons obtenu une collection de valeurs depuis la Map. Nous pouvons maintenant 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 le moment ; il convient de mentionner qu'un Set est une structure de données qui contient exclusivement des valeurs uniques.

Examinons cette méthode :

Set<K> keySet(): retourne une vue de type 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 du Map.

Nous avons donc terminé avec les méthodes. Examinons maintenant l'utilisation du 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 un 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 retrouver 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, cela peut être expliqué comme suit :

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 !

Parcours d'une Map

Le parcours des éléments dans une Map en Java peut s'effectuer à l'aide de différentes méthodes fournies par l'interface Map et ses implémentations. Voici plusieurs façons de parcourir une Map :

Parcours des clés (keySet()): la méthode keySet() retourne un ensemble de toutes les clés de 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() retourne 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() renvoie 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. Maintenant, résolvons la tâche mentionné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, nous utiliserons une vérification via entry.getValue(), et lorsque nous trouverons des étudiants correspondants, nous ajouterons leurs clés 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 le Map et de trouver la liste souhaitée d’étudiants ayant réussi l’examen !

L’ensemble des entrées est un outil très utile car il permet différentes façons d’itérer sur le Map à l’aide d’une boucle, tout en ayant 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 3. Chapitre 1

Demandez à l'IA

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

Suggested prompts:

Can you explain more about how HashMap handles collisions?

What are some other implementations of the Map interface besides HashMap?

Can you provide more practical examples of using Map in Java?

Glissez pour afficher le menu

Examinons la définition :

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 chevrons, 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

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.

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\"!");
        }
    }
}

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

Comme pour d'autres structures de données, il est possible de supprimer des éléments de la 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, nous pouvons supprimer des éléments par clé.

Méthodes de base pour la gestion des Maps

Ensuite, il existe des méthodes que vous connaissez déjà, que je vais énumérer sans exemples. Mais il reste aussi des méthodes intéressantes.

Commençons par les bases :

void clear(): supprime tous les éléments de la Map ;
int size(): retourne le nombre d’associations clé-valeur dans cette Map ;
void putAll(Map<? extends K, ? extends V> m): copie toutes les associations de la Map spécifiée 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);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Ici, nous avons obtenu une collection de valeurs depuis la Map. Nous pouvons maintenant 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.

Examinons cette méthode :

Set<K> keySet(): retourne une vue de type 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 du Map.

Nous avons donc terminé avec les méthodes. Examinons maintenant l'utilisation du 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.

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);
    }
}

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, cela peut être expliqué comme suit :

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");
        }
    }
}

Parcours d'une Map

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() retourne 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);
        }
    }
}

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);
        }
    }
}

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

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 le Map et de trouver la liste souhaitée d’étudiants ayant réussi l’examen !

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 3. Chapitre 1

Qu'est-ce qu'une Map ?

Méthodes

Méthodes de base pour la gestion des Maps

Utilisation de Map

Parcours d'une 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

Parcours d'une 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

Parcours d'une 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

Parcours d'une 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 ?

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 ?