Java Academy · Leçon

Ordre personnalisé dans les collections Tree

Fournissez un Comparator à TreeMap/TreeSet pour définir des ordres de tri propres à votre domaine.

Ordre personnalisé dans les collections Tree est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Pourquoi utiliser un ordre personnalisé ?

Les collections TreeMap et TreeSet utilisent par défaut l’ordre naturel. Lorsque vos objets métier n’ont pas d’ordre naturel, ou lorsque vous avez besoin d’un autre tri, fournissez un Comparator lors de la construction.

Comparator lors de la construction de TreeMap

Transmettez un comparateur pour trier les clés selon une règle personnalisée, par exemple dans l’ordre alphabétique inverse :

import java.util.*;

TreeMap<String, Integer> map = new TreeMap<>(Comparator.reverseOrder());
map.put("banana", 2);
map.put("apple", 1);
map.put("cherry", 3);

map.forEach((k,v) -> System.out.println(k)); // cherry, banana, apple

Comparator lors de la construction de TreeSet

Fournissez un comparateur à TreeSet pour contrôler l’ordre de tri indépendamment de l’ordre naturel des éléments :

TreeSet<String> byLength = new TreeSet<>(
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder())
);
byLength.addAll(List.of("fig","apple","kiwi","date","banana"));

for (String s : byLength) System.out.print(s + " ");
// fig date kiwi apple banana

Trier des objets selon plusieurs champs

Enchaînez les comparateurs pour trier selon un champ principal, puis selon un champ secondaire afin de départager les égalités :

record Employee(String name, String dept, int salary) {}

TreeSet<Employee> sorted = new TreeSet<>(
    Comparator.comparing(Employee::dept)
              .thenComparingInt(Employee::salary).reversed()
              .thenComparing(Employee::name)
);
sorted.add(new Employee("Alice", "Eng", 90_000));
sorted.add(new Employee("Bob",   "Eng", 85_000));
sorted.add(new Employee("Carol", "HR",  70_000));

for (Employee e : sorted) System.out.println(e.dept()+" "+e.name());

Cohérence avec l’égalité

Règle essentielle : le comparateur utilisé par TreeSet/TreeMap définit l’égalité pour la collection. Si comparator.compare(a, b) == 0, a et b sont considérés comme la même clé, même si a.equals(b) est faux.

// Comparator ignoring case — "apple" and "APPLE" become the same key!
TreeSet<String> ci = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
ci.add("apple");
ci.add("APPLE"); // not added — same by comparator
System.out.println(ci.size()); // 1

TreeMap insensible à la casse

Un besoin pratique courant consiste à utiliser une TreeMap dont les clés sont des chaînes insensibles à la casse, ce qui est utile pour les en-têtes HTTP et les clés de configuration :

TreeMap<String, String> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
headers.put("Content-Type", "application/json");
headers.put("content-type", "text/html"); // overwrites!

System.out.println(headers.get("CONTENT-TYPE")); // text/html
System.out.println(headers.size()); // 1

Comparator gérant les valeurs nulles

Les collections Tree utilisant l’ordre naturel lèvent NPE pour les clés nulles. Utilisez un comparateur gérant les valeurs nulles pour autoriser une clé nulle comme clé minimale :

TreeMap<String, Integer> map = new TreeMap<>(
    Comparator.nullsFirst(Comparator.naturalOrder())
);
map.put(null, 0);
map.put("b", 2);
map.put("a", 1);

map.forEach((k,v) -> System.out.println(k + "=" + v));
// null=0, a=1, b=2

Exemple d’objet métier : Product par prix

Triez les produits par prix dans un TreeSet, en utilisant le nom pour départager les égalités et préserver l’unicité :

record Product(String name, double price) {}

TreeSet<Product> catalog = new TreeSet<>(
    Comparator.comparingDouble(Product::price)
              .thenComparing(Product::name)
);
catalog.add(new Product("Widget", 9.99));
catalog.add(new Product("Gadget", 24.99));
catalog.add(new Product("Donut",  9.99));

catalog.forEach(p -> System.out.println(p.name() + " $" + p.price()));
// Donut $9.99, Widget $9.99, Gadget $24.99

Récupérer le comparateur

Appelez comparator() sur une TreeMap ou un TreeSet pour récupérer le comparateur personnalisé. La méthode renvoie null si l’ordre naturel est utilisé.

TreeMap<String, Integer> map = new TreeMap<>(Comparator.reverseOrder());
System.out.println(map.comparator() != null); // true

TreeMap<String, Integer> natural = new TreeMap<>();
System.out.println(natural.comparator());      // null

Composition de comparateurs

Le Comparator de Java propose des méthodes de fabrique chaînables pour composer les comparaisons proprement :

Comparator<String> comp =
    Comparator.comparingInt(String::length)   // by length
              .thenComparing(Comparator.naturalOrder()); // then alphabetically

TreeSet<String> ts = new TreeSet<>(comp);
ts.addAll(List.of("go", "java", "c", "rust", "py"));
ts.forEach(s -> System.out.print(s + " "));
// c go py java rust

Quand NOT utiliser un Comparator personnalisé

Évitez d’utiliser avec les clés de TreeMap ou les éléments de TreeSet un comparateur incompatible avec l’égalité : cela provoque des entrées « introuvables » déroutantes. Pour obtenir un comportement correct dans tous les contextes de collections, assurez-vous que compare(a, b) == 0 si et seulement si a.equals(b).

Vérification rapide

Un TreeSet utilise uniquement un comparateur fondé sur String::length. Que se passe-t-il lorsque vous ajoutez à la fois "cat" et "dog" ?

Récapitulatif : ordre personnalisé

Points essentiels :

Transmettez un Comparator au constructeur de TreeMap/TreeSet pour définir un ordre personnalisé
L’égalité définie par Comparator détermine l’unicité dans les collections arborescentes
Veillez à ce que le comparateur soit cohérent avec equals afin d’éviter les surprises
Utilisez Comparator.nullsFirst/nullsLast pour un ordre compatible avec null
Utilisez thenComparing pour enchaîner un tri sur plusieurs champs

Questions Fréquemment Posées

La leçon « Ordre personnalisé dans les collections Tree » est-elle gratuite ?

Oui — le texte complet de « Ordre personnalisé dans les collections Tree » 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 « Ordre personnalisé dans les collections Tree » ?

Fournissez un Comparator à TreeMap/TreeSet pour définir des ordres de tri propres à votre domaine. 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 4 sur 4.

Combien de temps prend la leçon « Ordre personnalisé dans les collections Tree » ?

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

TreeMap : paires clé-valeur triées
Sous-cartes et vues d’intervalles
TreeSet et NavigableSet
Ordre personnalisé dans les collections Tree

← Retour à Java Academy