Java TreeMap

Dans ce tutoriel, nous allons apprendre la classe Java TreeMap et ses opérations à l'aide d'exemples.

Il hérite deInterface NavigableMap.

Créer une TreeMap

Pour créer une TreeMap, nous devons d'abord importer le paquet java.util.TreeMap. Après avoir importé le programme paquet, vous pouvez créer une TreeMap en utilisant la méthode suivante en Java.

TreeMap<Key, Value> numbers = new TreeMap<>();

Dans le code ci-dessus, nous avons créé une TreeMap nommée numbers sans aucun paramètre. Dans cet exemple, les éléments de TreeMap sont triés de manière naturelle (en ordre croissant).

Cependant, nous pouvons personnaliser le tri des éléments en utilisant l'interface Comparator. Nous en apprendrons davantage sur cela dans la partie suivante de ce tutoriel.

Ici,

• Clé - Utilisé comme identificateur unique pour chaque élément (valeur) de la carte

• Valeur - L'élément associé à la clé dans la carte

Les méthodes de TreeMap

La classe TreeMap fournit diverses méthodes permettant d'effectuer des opérations sur la carte.

Insérer l'élément dans TreeMap

• put() - Insérer la clé spécifiée/Insérer le mapping des valeurs (entrées) dans la carte

• putAll() - Insérer tous les éléments de la carte spécifiée dans cette carte

• putIfAbsent() - Si le mapping ne contient pas la clé spécifiée, insérer la clé spécifiée/Insérer le mapping des valeurs dans la map

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un TreeMap des nombres pairs
　　　　　　　　TreeMap<String, Integer> evenNumbers = new TreeMap<>();
　　　　　　　　//　Utiliser put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　Utiliser putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("Le TreeMap des nombres pairs: "　+　evenNumbers);
　　　　　　　　//Créer un TreeMap de nombres
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　Utiliser putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("Les nombres de TreeMap: "　+　numbers);
　　　　}
}

Output result

Le TreeMap des nombres pairs: {Four=4, Six=6, Two=2}
Les nombres de TreeMap: {Four=4, One=1, Six=6, Two=2}

Accéder aux éléments de TreeMap

1.Utiliser entrySet(), keySet() et values()

• entrySet() - Retourner toutes les clés de TreeMap/L'ensemble des mappings des valeurs (entrées)

• keySet() - Retourner l'ensemble des clés de TreeMap

• values() - Retourner l'ensemble des graphes de TreeMap

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Utiliser entrySet()
　　　　　　　　System.out.println("Clé"/Mapping des valeurs: "　+　numbers.entrySet());
　　　　　　　　//　Utiliser keySet()
　　　　　　　　System.out.println("Clés: "　+　numbers.keySet());
　　　　　　　　//　Utiliser values()
　　　　　　　　System.out.println("Valeurs: ")　+　numbers.values());
　　　　}
}

Output result

TreeMap: {One=1, Three=3, Two=2}
Clé/Mapping des valeurs: [One=1, Three=3, Two=2]
Clés: [One, Three, Two]
Valeurs: [1,　3,　2]

2.Utilisez get() et getOrDefault()

• get() - Retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, retourne null.

• getOrDefault() - Retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, retourne la valeur par défaut spécifiée.

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Utilisez get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("Utilisez get(): ")　+　value1);
　　　　　　　　//　Utilisez getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("Utilisez getOrDefault(): ")　+　value2);
　　　　}
}

Output result

TreeMap: {One=1, Three=3, Two=2}
Utilisez get():　3
Utilisez getOrDefault():　5

Supprimer l'élément TreeMap

• remove(key) - Retournez et supprimez l'entrée associée à la clé spécifiée dans TreeMap

• remove(key, value) -Supprimez l'entrée de la carte uniquement si la clé spécifiée est associée à la valeur spécifiée, et retournez une valeur booléenne

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//Méthode de suppression avec un paramètre
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Valeur supprimée: "　+　value);
　　　　　　　　//Méthode de suppression avec deux paramètres
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("Entrée {Three=3} a-t-il été supprimé? "　+　result);
　　　　　　　　System.out.println("TreeMap mis à jour : ");　+　numbers);
　　　　}
}

Output result

TreeMap: {One=1, Three=3, Two=2}
Valeur supprimée =　2
Entrée {Three=3} a-t-il été supprimé? True
TreeMap mis à jour: {One=1}

Remplacer l'élément TreeMap

• replace(key, value)-Utilisez la clé nouvelle pour remplacer la valeur associée à la correspondance spécifiée value

• replace(key, old, new) -Remplacez uniquement la valeur ancienne par la nouvelle valeur si l'ancienne valeur est déjà associée à la clé spécifiée

• replaceAll(function) -Remplacez chaque valeur du map avec une valeur spécifiée fonction

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap original : "　+　numbers);
　　　　　　　　//　Utilisation de replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("TreeMap utilise la méthode replace() : "　+　numbers);
　　　　　　　　//　Utilisation de replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　-> oldValue　+　2);
　　　　　　　　System.out.println("TreeMap utilise la méthode replaceAll() : "　+　numbers);
　　　　}
}

Output result

TreeMap original : {First=1, Second=2, Third=3}
TreeMap utilise la méthode replace() : {First=1, Second=22, Third=33}
TreeMap utilise la méthode replaceAll() : {First=3, Second=24, Third=35}

Dans le programme ci-dessus, notez l'instruction

numbers.replaceAll((key, oldValue)　-> oldValue　+　2);

Ici, nous avons passé uneExpression lambdaEn tant que paramètre.

La méthode replaceAll() accède à toutes les entrées du map. Ensuite, elle remplace tous les éléments par de nouvelles valeurs (retournées par l'expression lambda).

Méthodes de navigation

Comme la classe TreeMap implémente NavigableMap, elle fournit diverses méthodes de navigation sur les éléments de TreeMap.

1.Première et dernière méthodes

• firstKey() - Retourne la première clé du map

• firstEntry() - Retourne la clé de la première entrée du mapping/Mapping des valeurs

• lastKey() - Retourne la dernière clé du map

• lastEntry() - Retourne la clé de la dernière entrée du mapping/Mapping des valeurs

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Utilisation de la méthode firstKey()
　　　　　　　　String firstKey = numbers.firstKey();
　　　　　　　　System.out.println("Première clé : " );　+　firstKey);
　　　　　　　　//　Utilisation de la méthode lastKey()
　　　　　　　　String lastKey = numbers.lastKey();
　　　　　　　　System.out.println("Dernière clé : " );　+　lastKey);
　　　　　　　　//　Utilisation de la méthode firstEntry()
　　　　　　　　System.out.println("Premier élément : " );　+　numbers.firstEntry());
　　　　　　　　//　Utilisation de la méthode lastEntry()
　　　　　　　　System.out.println("Dernière valeur : ");　+　numbers.lastEntry());
　　　　}
}

Output result

TreeMap: {First=1, Second=2, Third=3}
Première clé : First
Dernière clé : Third
Première valeur : First=1
Dernière valeur : Third=3

2.Méthodes de bornes supérieure et inférieure, de haut et de bas

• HigherKey() - Retourne la clé la plus petite parmi celles qui sont supérieures à la clé spécifiée.

• HigherEntry() - Retourne l'entrée associée à la clé la plus petite parmi celles qui sont supérieures à la clé spécifiée.

• lowerKey() - Retourne la clé la plus grande parmi celles qui sont inférieures à la clé spécifiée.

• lowerEntry() - Retourne l'entrée associée à la clé la plus grande parmi celles qui sont inférieures à la clé spécifiée.

• ceilingKey() - Retourne la clé la plus petite parmi celles qui sont supérieures à la clé spécifiée. Si l'image de la carte contient une clé passée en paramètre, alors elle retourne cette clé.

• ceilingEntry() - Retourne l'entrée associée à la clé la plus petite parmi celles qui sont supérieures à la clé spécifiée. Si l'image de la carte contient une entrée associée à la clé passée en argument, elle retourne cette entrée.

• floorKey() - Retourne la clé la plus grande parmi celles qui sont inférieures à la clé spécifiée. Si la clé passée en paramètre existe, elle retourne cette clé.

• floorEntry() - Retourne l'entrée associée à la clé la plus grande parmi celles qui sont inférieures à la clé spécifiée. Si la clé passée en paramètre existe, elle retourne cette clé.

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　5);
　　　　　　　　numbers.put("Third",　4);
　　　　　　　　numbers.put("Fourth",　6);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//　Utilisation de higher()
　　　　　　　　System.out.println("Utilisation de higherKey(): ");　+　numbers.higherKey("Fourth"));
　　　　　　　　System.out.println("Utilisation de higherEntry(): ");　+　numbers.higherEntry("Fourth"));
　　　　　　　　//　Utilisation de lower()
　　　　　　　　System.out.println("\nUtilisation de lowerKey(): ");　+　numbers.lowerKey("Fourth"));
　　　　　　　　System.out.println("Utilisation de lowerEntry(): ");　+　numbers.lowerEntry("Fourth"));
　　　　　　　　//　Utilisation de ceiling()
　　　　　　　　System.out.println("\nUtilisation de ceilingKey(): ");　+　numbers.ceilingKey("Fourth"));
　　　　　　　　System.out.println("Utilisation de ceilingEntry(): ");　+　numbers.ceilingEntry("Fourth"));
　　　　　　　　//　Utilisation de floor()
　　　　　　　　System.out.println("\nUtilisation de floorKey(): ");　+　numbers.floorKey("Fourth"));
　　　　　　　　System.out.println("Utilisation de floorEntry(): ");　+　numbers.floorEntry("Fourth"));
　　　　}
}

Output result

TreeMap: {First=1, Fourth=6, Second=5, Third=4}
Utilisation de higherKey(): Second
Utilisation de higherEntry(): Second=5
Utilisation de lowerKey(): First
Utilisation de lowerEntry(): First=1
Utilisation de ceilingKey(): Fourth
Utilisation de ceilingEntry(): Fourth=6
Utilisation de floorkey(): Fourth
Utilisation de floorEntry(): Fourth=6

3. Les méthodes pollFirstEntry() et pollLastEntry()

• pollFirstEntry() - Retourne et supprime l'entrée associée à la première clé de la carte

• pollLastEntry()　 -Retourne et supprime l'entrée associée à la dernière clé de la carte

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　//Utilisation de la méthode pollFirstEntry()
　　　　　　　　System.out.println("Utilisation de pollFirstEntry(): ");　+　numbers.pollFirstEntry());
　　　　　　　　//　Utilisation de la méthode pollLastEntry()
　　　　　　　　System.out.println("Utilisation de pollLastEntry(): ");　+　numbers.pollLastEntry());
　　　　　　　　System.out.println("TreeMap mis à jour : ");　+　numbers);
　　　　}
}

Output result

TreeMap: {First=1, Second=2, Third=3}
Utilisation de pollFirstEntry(): First=1
Utilisation de pollLastEntry(): Third=3
TreeMap mise à jour : {Second=2}

4. Les méthodes headMap(), tailMap() et subMap()

headMap(key,booleanValue)

Le paramètre booleanValue est optionnel. La valeur par défaut est false.

Si la valeur booléenne est true, cette méthode inclut également la clé spécifiée/paires de valeurs.

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUtilisation de la méthode headMap() ;");
　　　　　　　　//　headMap() utilise la valeur par défaut booleanValue pour false
　　　　　　　　System.out.println("Ne spécifiez pas de valeur booléenne: "　+　numbers.headMap("Fourth"));
　　　　　　　　//　headMap() utilise la valeur spécifiée booleanValue pour true
　　　　　　　　System.out.println("Spécifiez la valeur booléenne true: "　+　numbers.headMap("Fourth", true));
　　　　}
}

Output result

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Utilisez la méthode headMap()　
Ne spécifiez pas de valeur booléenne: {First=1}
Spécifiez la valeur booléenne true: {First=1, Fourth=4}

tailMap(key,booleanValue)

La méthode tailMap() commence à retourner toutes les clés du TreeMap en fonction de la clé spécifiée (passée en paramètre)/paires de valeurs.

booleanValue est un paramètre optionnel. La valeur par défaut est true.

Si booleanValue est false, cette méthode ne contient pas la clé spécifiée/paires de valeurs.

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUtilisez la méthode tailMap(): ");
　　　　　　　　//　tailMap() utilise la valeur par défaut true pour booleanValue
　　　　　　　　System.out.println("booleanValue en utilisant true par défaut: "　+　numbers.tailMap("Second"));
　　　　　　　　//　tailMap() utilise la valeur spécifiée false pour booleanValue
　　　　　　　　System.out.println("booleanValue en utilisant false spécifié: "　+　numbers.tailMap("Second", false));
　　　　}
}

Output result

TreeMap: {First=1, Fourth=4, Second=2, Third=3}
Utilisez la méthode tailMap()
booleanValue en utilisant true par défaut: {Second=2, Third=3}
booleanValue en utilisant false spécifié: {Third=3}

subMap(k1,bV1,k2,bV2)

la méthode subMap() retourne les entrées associées à k1et k2les entrées associées aux clés entre1des entrées.

bV1et bV2est un paramètre booléen optionnel. bV1vaut true par défaut, bV2vaut false par défaut.

si bV1si bV est false, alors cette méthode retourne les entrées associées à k1et k2les entrées associées aux clés entre1des entrées.

si bV2si bV est true, alors cette méthode retourne les entrées associées à k1et k2les entrées associées aux clés entre2des entrées.

Par exemple,

import java.util.TreeMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　　　　　System.out.println("\nUtiliser la méthode subMap():");
　　　　　　　　//　tailMap() utiliser une valeur booléenne par défaut
　　　　　　　　System.out.println("Utiliser une valeur booléenne par défaut: ")　+　numbers.subMap("Fourth", "Third"));
　　　　　　　　//　tailMap() spécifier une valeur booléenne
　　　　　　　　System.out.println("Spécifier une valeur booléenne: ")　+　numbers.subMap("Fourth", false, "Third", true));
　　　　}
}

Output result

TreeMap: {First=1, Fourth=2, Second=2, Third=3}
Utiliser la méthode subMap():
Utiliser une valeur booléenne par défaut: {Fourth=4, Second=2}
Spécifier une valeur booléenne: {Second=2, Third=3}

Autres méthodes TreeMap

Comparateur TreeMap

Dans tous les exemples ci-dessus, les éléments du TreeMap sont triés naturellement (par ordre croissant). Cependant, nous pouvons également définir notre propre ordre des clés.

Pour cela, nous devons créer notre propre classe comparateur basée sur le tri des clés du TreeMap. Par exemple,

import java.util.TreeMap;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un TreeMap avec un comparateur personnalisé
　　　　　　　　TreeMap<String, Integer> numbers = new TreeMap<>(new CustomComparator());
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　numbers.put("Fourth",　4);
　　　　　　　　System.out.println("TreeMap: "　+　numbers);
　　　　}
　　　　//Créer une classe comparateur
　　　　public static class CustomComparator implements Comparator<String> {
　　　　　　　　@Override
　　　　　　　　public int compare(String number1, String number2) {
　　　　　　　　　　　　int value =  number1.compareTo(number2);
　　　　　　　　　　　　//Elements are sorted in reverse order
　　　　　　　　　　　　if (value > 0) {
　　　　　　　　　　　　　　　　return　-1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else if (value < 0) {
　　　　　　　　　　　　　　　　return　1;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　　　　　　　　　　　　　　　return 0;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Output result

TreeMap: {Third=3, Second=2, Fourth=4, First=1}

In the above example, we created a TreeMap and passed the CustomComparator class as a parameter.

The CustomComparator class implements the Comparator interface.

Then override the compare() method to sort elements in reverse order.