0Pricing
Java Academy · Leçon

TreeMap : paires clé-valeur triées

Utilisez TreeMap pour conserver un ordre trié et naviguez avec firstKey, lastKey, floorKey et ceilingKey.

TreeMap : paires clé-valeur triées est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Qu’est-ce que TreeMap ?

TreeMap est une implémentation de map triée reposant sur un arbre rouge-noir. Les clés sont conservées dans l’ordre naturel croissant, ou selon l’ordre d’un comparateur personnalisé. Toutes les opérations de base sont en O(log n).

import java.util.TreeMap;

TreeMap<String, Integer> scores = new TreeMap<>();
scores.put("Charlie", 85);
scores.put("Alice", 92);
scores.put("Bob", 78);

// Iteration is in key order: Alice, Bob, Charlie
for (var entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

firstKey, lastKey, floorKey, ceilingKey

L’interface NavigableMap de TreeMap expose des méthodes de navigation permettant de trouver des clés par rapport à une valeur donnée :

TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "ten"); map.put(20, "twenty"); map.put(30, "thirty"); map.put(40, "forty");

System.out.println(map.firstKey());       // 10
System.out.println(map.lastKey());        // 40
System.out.println(map.floorKey(25));     // 20 (largest key ≤ 25)
System.out.println(map.ceilingKey(25));   // 30 (smallest key ≥ 25)
System.out.println(map.lowerKey(20));     // 10 (strictly less)
System.out.println(map.higherKey(20));    // 30 (strictly greater)

Navigation parmi les entrées

floorEntry, ceilingEntry, firstEntry et lastEntry renvoient l’objet Map.Entry complet, plutôt que la clé seule :

TreeMap<Integer, String> prices = new TreeMap<>();
prices.put(100, "Budget"); prices.put(300, "Standard"); prices.put(700, "Premium");

var entry = prices.floorEntry(350);
System.out.println(entry.getKey() + ": " + entry.getValue()); // 300: Standard

var top = prices.lastEntry();
System.out.println(top.getValue()); // Premium

subMap, headMap, tailMap

Extrayez des vues d’intervalles depuis une TreeMap. Ces vues sont adossées à la map d’origine : les modifications effectuées dans l’une se reflètent dans l’autre.

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i, "v"+i);

// Keys from 3 (inclusive) to 7 (exclusive)
System.out.println(map.subMap(3, 7));   // {3=v3, 4=v4, 5=v5, 6=v6}

// Keys strictly less than 5
System.out.println(map.headMap(5));     // {1=v1, 2=v2, 3=v3, 4=v4}

// Keys >= 7
System.out.println(map.tailMap(7));     // {7=v7, 8=v8, 9=v9, 10=v10}

Limites inclusives et exclusives

Utilisez les variantes surchargées pour contrôler précisément les limites :

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i*10, "v"+i);

// From 30 (inclusive) to 60 (inclusive)
System.out.println(map.subMap(30, true, 60, true));
// {30=v3, 40=v4, 50=v5, 60=v6}

Ordre décroissant

Utilisez descendingMap() ou descendingKeySet() pour parcourir les clés dans l’ordre inverse :

TreeMap<String, Integer> tm = new TreeMap<>();
tm.put("A", 1); tm.put("C", 3); tm.put("B", 2);

for (String key : tm.descendingKeySet()) {
    System.out.print(key + " "); // C B A
}

pollFirstEntry et pollLastEntry

Supprimez et renvoyez atomiquement la première ou la dernière entrée : c’est utile pour créer des maps de priorité :

TreeMap<Integer, String> events = new TreeMap<>();
events.put(8, "Breakfast");
events.put(12, "Lunch");
events.put(18, "Dinner");

var first = events.pollFirstEntry(); // removes 8=Breakfast
System.out.println(first.getValue() + " removed");
System.out.println(events.firstKey()); // 12

Cas d’utilisation : classement

Un classement doit trier les joueurs par score. TreeMap trie automatiquement selon la clé :

TreeMap<Integer, String> leaderboard = new TreeMap<>(Comparator.reverseOrder());
leaderboard.put(1200, "Alice");
leaderboard.put(1500, "Bob");
leaderboard.put(900, "Carol");

int rank = 1;
for (var e : leaderboard.entrySet()) {
    System.out.println(rank++ + ". " + e.getValue() + " (" + e.getKey() + ")");
}
// 1. Bob (1500)
// 2. Alice (1200)
// 3. Carol (900)

Cas d’utilisation : planificateur d’événements

Associez des horodatages à des événements et utilisez ceilingEntry pour trouver le prochain événement planifié après une heure donnée :

import java.time.LocalTime;
TreeMap<LocalTime, String> schedule = new TreeMap<>();
schedule.put(LocalTime.of(9,0), "Standup");
schedule.put(LocalTime.of(14,0), "Review");
schedule.put(LocalTime.of(17,0), "Retro");

LocalTime now = LocalTime.of(11, 30);
var next = schedule.ceilingEntry(now);
System.out.println("Next: " + next.getValue()); // Review

Performances de TreeMap et HashMap

Comparaison des caractéristiques :

  • HashMap : get/put en O(1) en moyenne ; ordre non défini
  • TreeMap : get/put en O(log n) ; triée selon les clés
  • LinkedHashMap : O(1) en moyenne ; ordre d’insertion conservé

Utilisez TreeMap lorsque vous avez besoin de clés triées ou de requêtes par intervalle. HashMap est plus rapide pour rechercher simplement une clé.

Sécurité des threads

TreeMap n’est pas sûre pour les accès concurrents (NOT). Pour les accès simultanés, utilisez ConcurrentSkipListMap, qui conserve également l’ordre trié avec des opérations en O(log n) et prend en charge les lectures et écritures concurrentes.

Vérification rapide

Vous disposez d’une TreeMap<Integer, String> dont les clés sont {10, 20, 30, 40}. Que renvoie map.floorKey(25) ?

Récapitulatif : TreeMap

Points essentiels :

  • TreeMap conserve les clés dans l’ordre trié croissant grâce à un arbre rouge-noir
  • Toutes les opérations sont en O(log n)
  • Navigation : firstKey, lastKey, floorKey, ceilingKey, lowerKey, higherKey
  • Vues d’intervalles : subMap, headMap, tailMap, adossées à la map d’origine
  • Utilisez ConcurrentSkipListMap pour les maps triées sûres pour les accès concurrents

Questions Fréquemment Posées

La leçon « TreeMap : paires clé-valeur triées » est-elle gratuite ?

Oui — le texte complet de « TreeMap : paires clé-valeur triées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « TreeMap : paires clé-valeur triées » ?

Utilisez TreeMap pour conserver un ordre trié et naviguez avec firstKey, lastKey, floorKey et ceilingKey. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « TreeMap : paires clé-valeur triées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. TreeMap : paires clé-valeur triées
  2. Sous-cartes et vues d’intervalles
  3. TreeSet et NavigableSet
  4. Ordre personnalisé dans les collections Tree
← Retour à Java Academy