Java TreeMap : Maîtriser les Maps Triées avec Exemples Pratiques

Java TreeMap

Explorez la classe Java TreeMap – une implémentation de map naturellement triée puissante – avec des exemples clairs, opérations clés et techniques de navigation avancées.

La classe TreeMap fait partie du Java Collections Framework et fournit une implémentation d'arbre rouge-noir qui garde ses entrées triées selon l'ordre naturel des clés ou un Comparator personnalisé. Elle implémente l'interface NavigableMap, qui ajoute des méthodes pratiques pour parcourir et interroger la map.

Création d'un TreeMap

Avant d'utiliser un TreeMap, importez le package :

import java.util.TreeMap;

Puis créez une instance :

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

Par défaut, les clés sont triées dans l'ordre naturel croissant. Si vous avez besoin d'un ordre personnalisé, passez un Comparator au constructeur.

Key – identifiant unique pour chaque entrée.
Value – donnée associée à la clé.

Aperçu des Méthodes TreeMap

La classe offre un riche ensemble d'opérations. Voici les catégories clés avec extraits de code.

Insertion d'Éléments

put() – ajoute ou remplace une paire clé/valeur.
putAll() – fusionne une autre map dans celle-ci.
putIfAbsent() – insère seulement si la clé manque.

Exemple :

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

Sortie

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

Accès aux Éléments

Utilisation des Vues de Collection

entrySet() – retourne toutes les paires clé/valeur.
keySet() – retourne toutes les clés.
values() – retourne toutes les valeurs.

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);
        System.out.println("Mappings Clé/Valeur: " + numbers.entrySet());
        System.out.println("Clés: " + numbers.keySet());
        System.out.println("Valeurs: " + numbers.values());
    }
}

Sortie

TreeMap: {One=1, Three=3, Two=2} Mappings Clé/Valeur: [One=1, Three=3, Two=2] Clés: [One, Three, Two] Valeurs: [1, 3, 2]

Récupération de Valeurs

get() – retourne la valeur pour une clé ou null si absente.
getOrDefault() – retourne une valeur par défaut si la clé manque.

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);
        int value1 = numbers.get("Three");
        System.out.println("Avec get(): " + value1);
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Avec getOrDefault(): " + value2);
    }
}

Sortie

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

Suppression d'Entrées

remove(key) – supprime l'entrée et retourne sa valeur.
remove(key, value) – supprime seulement si la clé mappe vers la valeur spécifiée.

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);
        int removed = numbers.remove("Two");
        System.out.println("Valeur supprimée: " + removed);
        boolean removedPair = numbers.remove("Three", 3);
        System.out.println("L'entrée {Three=3} est-elle supprimée? " + removedPair);
        System.out.println("TreeMap Mis à Jour: " + numbers);
    }
}

Sortie

TreeMap: {One=1, Three=3, Two=2} Valeur supprimée: 2 L'entrée {Three=3} est-elle supprimée? true TreeMap Mis à Jour: {One=1}

Remplacement de Valeurs

replace(key, value) – met à jour la valeur pour une clé.
replace(key, old, new) – met à jour seulement si la valeur courante correspond à old.
replaceAll(function) – applique une fonction à chaque entrée.

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);
        numbers.replace("Second", 22);
        numbers.replace("Third", 3, 33);
        System.out.println("Après replace(): " + numbers);
        numbers.replaceAll((k, v) -> v + 2);
        System.out.println("Après replaceAll(): " + numbers);
    }
}

Sortie

TreeMap Original: {First=1, Second=2, Third=3} Après replace(): {First=1, Second=22, Third=33} Après replaceAll(): {First=3, Second=24, Third=35}

Puisque TreeMap implémente NavigableMap, elle offre des méthodes pour interroger la structure efficacement.

Premiers et Derniers Éléments

firstKey() – première clé dans l'ordre.
firstEntry() – entrée pour la première clé.
lastKey() – dernière clé.
lastEntry() – entrée pour la dernière clé.

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);
        System.out.println("Première Clé: " + numbers.firstKey());
        System.out.println("Dernière Clé: " + numbers.lastKey());
        System.out.println("Première Entrée: " + numbers.firstEntry());
        System.out.println("Dernière Entrée: " + numbers.lastEntry());
    }
}

Sortie

TreeMap: {First=1, Second=2, Third=3} Première Clé: First Dernière Clé: Third Première Entrée: First=1 Dernière Entrée: Third=3

Ceiling, Floor, Higher et Lower

Ces méthodes retournent des clés ou entrées relatives à une clé donnée, facilitant les requêtes de plage.

higherKey(), higherEntry() – clé/entrée suivante supérieure.
lowerKey(), lowerEntry() – clé/entrée précédente inférieure.
ceilingKey(), ceilingEntry() – plus petite clé/entrée ≥ clé donnée.
floorKey(), floorEntry() – plus grande clé/entrée ≤ clé donnée.

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);
        System.out.println("higherKey('Fourth'): " + numbers.higherKey("Fourth"));
        System.out.println("higherEntry('Fourth'): " + numbers.higherEntry("Fourth"));
        System.out.println("lowerKey('Fourth'): " + numbers.lowerKey("Fourth"));
        System.out.println("lowerEntry('Fourth'): " + numbers.lowerEntry("Fourth"));
        System.out.println("ceilingKey('Fourth'): " + numbers.ceilingKey("Fourth"));
        System.out.println("ceilingEntry('Fourth'): " + numbers.ceilingEntry("Fourth"));
        System.out.println("floorKey('Fourth'): " + numbers.floorKey("Fourth"));
        System.out.println("floorEntry('Fourth'): " + numbers.floorEntry("Fourth"));
    }
}

Sortie

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

Polling et Plages

pollFirstEntry() et pollLastEntry() suppriment et retournent les premières/dernières entrées respectivement.

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);
        System.out.println("pollFirstEntry(): " + numbers.pollFirstEntry());
        System.out.println("pollLastEntry(): " + numbers.pollLastEntry());
        System.out.println("TreeMap Mis à Jour: " + numbers);
    }
}

Sortie

TreeMap: {First=1, Second=2, Third=3} pollFirstEntry(): First=1 pollLastEntry(): Third=3 TreeMap Mis à Jour: {Second=2}

headMap, tailMap, subMap

Ces méthodes fournissent des vues sur des plages de clés spécifiques.

headMap(toKey, inclusive) – clés < toKey (ou ≤ si inclusive).
tailMap(fromKey, inclusive) – clés ≥ fromKey (ou > si exclusif).
subMap(fromKey, fromInclusive, toKey, toInclusive) – clés entre les deux bornes.

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("headMap('Fourth'): " + numbers.headMap("Fourth"));
        System.out.println("headMap('Fourth', true): " + numbers.headMap("Fourth", true));
        System.out.println("tailMap('Second'): " + numbers.tailMap("Second"));
        System.out.println("tailMap('Second', false): " + numbers.tailMap("Second", false));
        System.out.println("subMap('Fourth', true, 'Third', false): " + numbers.subMap("Fourth", true, "Third", false));
    }
}

Sortie

TreeMap: {First=1, Fourth=4, Second=2, Third=3} headMap('Fourth'): {First=1} headMap('Fourth', true): {First=1, Fourth=4} tailMap('Second'): {Second=2, Third=3, Fourth=4} tailMap('Second', false): {Third=3, Fourth=4} subMap('Fourth', true, 'Third', false): {Fourth=4, Second=2}

Méthodes Utilitaires Supplémentaires

Méthode	Description
`clone()`	Crée une copie superficielle de la map.
`containsKey()`	Vérifie la présence d'une clé.
`containsValue()`	Vérifie une valeur spécifique.
`size()`	Retourne le nombre d'entrées.
`clear()`	Supprime toutes les entrées.

Ordre de Clés Personnalisé avec Comparator

Pour trier les clés différemment – comme ordre inverse ou chaînes insensibles à la casse – implémentez Comparator et passez-le au constructeur TreeMap.

import java.util.TreeMap;
import java.util.Comparator;
class Main {
    public static void main(String[] args) {
        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);
    }
    static class CustomComparator implements Comparator<String> {
        @Override
        public int compare(String a, String b) {
            // Ordre naturel inverse
            return a.compareTo(b) * -1;
        }
    }
}

Sortie

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

Pour plus sur Comparator, voir la documentation officielle Java.

Maîtriser Java NavigableMap : Fonctionnalités, Méthodes et Implémentation TreeMap Maîtriser ConcurrentMap de Java : Maps Thread-Safe Expliquées

Java

Java TreeMap : Maîtriser les Maps Triées avec Exemples Pratiques

Java TreeMap

Création d'un TreeMap

Aperçu des Méthodes TreeMap

Insertion d'Éléments

Accès aux Éléments

Utilisation des Vues de Collection

Récupération de Valeurs

Suppression d'Entrées

Remplacement de Valeurs

Méthodes de Navigation

Premiers et Derniers Éléments

Ceiling, Floor, Higher et Lower

Polling et Plages

headMap, tailMap, subMap

Méthodes Utilitaires Supplémentaires

Ordre de Clés Personnalisé avec Comparator