0Pricing
Java Academy · Leçon

TreeSet et NavigableSet

Stockez des éléments triés et uniques, puis utilisez floor, ceiling, higher et lower pour rechercher les voisins les plus proches.

TreeSet et NavigableSet est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 TreeSet ?

TreeSet est un ensemble trié reposant sur un arbre rouge-noir. Il stocke des éléments uniques dans l’ordre naturel croissant, ou selon le comparateur fourni. Toutes les opérations sont en O(log n).

import java.util.TreeSet;

TreeSet<String> names = new TreeSet<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
names.add("Alice"); // duplicate ignored

for (String s : names) System.out.print(s + " ");
// Alice Bob Charlie

Méthodes de NavigableSet : floor, ceiling, lower, higher

TreeSet implémente NavigableSet et fournit des méthodes de navigation permettant de trouver les éléments les plus proches :

TreeSet<Integer> set = new TreeSet<>();
for (int i = 10; i <= 50; i += 10) set.add(i);
// {10, 20, 30, 40, 50}

System.out.println(set.floor(25));   // 20 (greatest ≤ 25)
System.out.println(set.ceiling(25)); // 30 (smallest ≥ 25)
System.out.println(set.lower(30));   // 20 (strictly less)
System.out.println(set.higher(30));  // 40 (strictly greater)

first, last, pollFirst, pollLast

Accédez aux éléments situés aux limites ou supprimez-les :

TreeSet<String> ts = new TreeSet<>(Set.of("cherry","apple","banana","date"));

System.out.println(ts.first());       // apple
System.out.println(ts.last());        // date
System.out.println(ts.pollFirst());   // apple (removed)
System.out.println(ts.pollLast());    // date (removed)
System.out.println(ts);              // [banana, cherry]

headSet, tailSet, subSet

Extrayez des vues de sous-ensembles triés :

TreeSet<Integer> set = new TreeSet<>(Set.of(1,2,3,4,5,6,7,8,9,10));

System.out.println(set.headSet(5));      // [1, 2, 3, 4]
System.out.println(set.tailSet(7));      // [7, 8, 9, 10]
System.out.println(set.subSet(3, 7));    // [3, 4, 5, 6]

// Inclusive upper bound:
System.out.println(set.subSet(3, true, 7, true)); // [3,4,5,6,7]

Parcours dans l’ordre inverse

Utilisez descendingIterator() ou descendingSet() pour parcourir les éléments dans l’ordre inverse :

TreeSet<Integer> ts = new TreeSet<>(Set.of(1,3,5,7,9));

// Descending iterator
var it = ts.descendingIterator();
while (it.hasNext()) System.out.print(it.next() + " ");
// 9 7 5 3 1

Tri personnalisé avec Comparator

Transmettez un Comparator pour trier selon un ordre différent de l’ordre naturel, par exemple les chaînes de la plus longue à la plus courte :

TreeSet<String> byLength = new TreeSet<>(
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder())
);
byLength.add("Hi");
byLength.add("Hello");
byLength.add("Hey");
byLength.add("Java");

for (String s : byLength) System.out.print(s + " ");
// Hi Hey Java Hello

Cas d’utilisation : noms d’utilisateur uniques et triés

Stockez les noms d’utilisateur dans un TreeSet pour supprimer automatiquement les doublons et conserver l’ordre alphabétique :

TreeSet<String> users = new TreeSet<>();
users.add("alice");
users.add("bob");
users.add("alice"); // ignored
users.add("carol");

System.out.println(users.first()); // alice
System.out.println(users);         // [alice, bob, carol]

Cas d’utilisation : comptage dans un intervalle

Comptez les éléments compris dans un intervalle à l’aide de subSet :

TreeSet<Integer> scores = new TreeSet<>();
for (int s : new int[]{45,62,78,55,90,88,34,71}) scores.add(s);

// Scores between 60 and 89 (inclusive)
int count = scores.subSet(60, true, 89, true).size();
System.out.println("Students in B range: " + count); // 3 (62, 78, 88... wait: 62,78,71,88=4)
// Actually: 62,71,78,88 = 4

TreeSet contre HashSet et LinkedHashSet

Choisissez en fonction de vos besoins :

  • HashSet : opérations en O(1), ordre non défini
  • LinkedHashSet : opérations en O(1), ordre d’insertion conservé
  • TreeSet : opérations en O(log n), ordre trié et méthodes de navigation

TreeSet exige que les éléments implémentent Comparable ou qu’un Comparator soit fourni.

Éléments nuls

TreeSet n’autorise pas les éléments nuls avec l’ordre naturel (NOT) : une NullPointerException est levée, car une valeur nulle ne peut pas être comparée. Un comparateur personnalisé qui gère explicitement les valeurs nulles fonctionnerait.

TreeSet<String> ts = new TreeSet<>();
try {
    ts.add(null); // throws NullPointerException
} catch (NullPointerException e) {
    System.out.println("Cannot add null: " + e);
}

Sécurité des threads

TreeSet n’est pas sûr pour les accès concurrents (NOT). Synchronisez-le vous-même avec Collections.synchronizedSortedSet(), ou utilisez ConcurrentSkipListSet, qui est à la fois trié et sûr pour les accès concurrents.

Vérification rapide

Un TreeSet<Integer> contient {10, 20, 30, 40, 50}. Que renvoie set.ceiling(35) ?

Récapitulatif : TreeSet et NavigableSet

Points essentiels :

  • TreeSet stocke des éléments uniques et triés (O(log n))
  • Il implémente NavigableSet : floor, ceiling, lower, higher, first et last
  • headSet, tailSet et subSet renvoient des vues d’intervalles adossées
  • Utilisez descendingSet()/descendingIterator() pour l’ordre inverse
  • Il n’est pas sûr pour les accès concurrents : utilisez ConcurrentSkipListSet pour les accès simultanés

Questions Fréquemment Posées

La leçon « TreeSet et NavigableSet » est-elle gratuite ?

Oui — le texte complet de « TreeSet et NavigableSet » 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 « TreeSet et NavigableSet » ?

Stockez des éléments triés et uniques, puis utilisez floor, ceiling, higher et lower pour rechercher les voisins les plus proches. 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 3 sur 4.

Combien de temps prend la leçon « TreeSet et NavigableSet » ?

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