Maîtriser Java TreeSet : Opérations, méthodes et exemples pratiques

La classe TreeSet du framework Java Collections fournit la fonctionnalité d'une structure de données arborescente. Elle implémente l'interface NavigableSet.

Création d'un TreeSet

Pour créer un ensemble arborescent, importez d'abord le package java.util.TreeSet :

TreeSet<Integer> nombres = new TreeSet<>();

Les éléments sont triés naturellement (ordre croissant). Vous pouvez personnaliser le tri en utilisant l'interface Comparator.

Méthodes de TreeSet

La classe TreeSet fournit diverses méthodes pour effectuer des opérations sur l'ensemble.

Insérer des éléments dans TreeSet

add() – insère l'élément spécifié
addAll() – insère tous les éléments de la collection spécifiée

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombresPairs = new TreeSet<>();
        nombresPairs.add(2);
        nombresPairs.add(4);
        nombresPairs.add(6);
        System.out.println("TreeSet : " + nombresPairs);

        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(1);
        nombres.addAll(nombresPairs);
        System.out.println("Nouveau TreeSet : " + nombres);
    }
}

Sortie

TreeSet : [2, 4, 6]
Nouveau TreeSet : [1, 2, 4, 6]

Accéder aux éléments d'un TreeSet

Pour accéder aux éléments, utilisez la méthode iterator() :

import java.util.TreeSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        Iterator<Integer> iterateur = nombres.iterator();
        System.out.print("TreeSet avec Iterator : ");
        while (iterateur.hasNext()) {
            System.out.print(iterateur.next() + ", ");
        }
    }
}

Sortie

TreeSet : [2, 5, 6]
TreeSet avec Iterator : 2, 5, 6,

Supprimer des éléments

remove() – supprime l'élément spécifié
removeAll() – supprime tous les éléments de l'ensemble

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        boolean val1 = nombres.remove(5);
        System.out.println("5 est-il supprimé ? " + val1);

        boolean val2 = nombres.removeAll(nombres);
        System.out.println("Tous les éléments sont-ils supprimés ? " + val2);
    }
}

Sortie

TreeSet : [2, 5, 6]
5 est-il supprimé ? true
Tous les éléments sont-ils supprimés ? true

Puisque TreeSet implémente NavigableSet, il fournit des méthodes pour naviguer sur les éléments.

1. first() et last()

first() – renvoie le premier élément
last() – renvoie le dernier élément

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);
        System.out.println("Premier nombre : " + nombres.first());
        System.out.println("Dernier nombre : " + nombres.last());
    }
}

Sortie

TreeSet : [2, 5, 6]
Premier nombre : 2
Dernier nombre : 6

2. ceiling(), floor(), higher() et lower()

higher(element) – Renvoie le plus petit élément strictement supérieur à element
lower(element) – Renvoie le plus grand élément strictement inférieur à element
ceiling(element) – Renvoie le plus petit élément supérieur ou égal à element (renvoie element s'il existe)
floor(element) – Renvoie le plus grand élément inférieur ou égal à element (renvoie element s'il existe)

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(4);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        System.out.println("higher(4) : " + nombres.higher(4));
        System.out.println("lower(4) : " + nombres.lower(4));
        System.out.println("ceiling(4) : " + nombres.ceiling(4));
        System.out.println("floor(3) : " + nombres.floor(3));
    }
}

Sortie

TreeSet : [2, 4, 5, 6]
higher(4) : 5
lower(4) : 2
ceiling(4) : 4
floor(3) : 2

3. pollFirst() et pollLast()

pollFirst() – renvoie et supprime le premier élément
pollLast() – renvoie et supprime le dernier élément

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(4);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        System.out.println("Premier élément supprimé : " + nombres.pollFirst());
        System.out.println("Dernier élément supprimé : " + nombres.pollLast());
        System.out.println("Nouveau TreeSet : " + nombres);
    }
}

Sortie

TreeSet : [2, 4, 5, 6]
Premier élément supprimé : 2
Dernier élément supprimé : 6
Nouveau TreeSet : [4, 5]

4. headSet(), tailSet() et subSet()

headSet(element, booleanValue)

Renvoie tous les éléments avant element. Par défaut booleanValue = false (exclusif). Si true, inclut l'élément.

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(4);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        System.out.println("headSet(5) : " + nombres.headSet(5));
        System.out.println("headSet(5, true) : " + nombres.headSet(5, true));
    }
}

Sortie

TreeSet : [2, 4, 5, 6]
headSet(5) : [2, 4]
headSet(5, true) : [2, 4, 5]

tailSet(element, booleanValue)

Renvoie tous les éléments après element y compris l'élément par défaut (booleanValue = true). Si false, exclut l'élément.

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(4);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        System.out.println("tailSet(4) : " + nombres.tailSet(4));
        System.out.println("tailSet(4, false) : " + nombres.tailSet(4, false));
    }
}

Sortie

TreeSet : [2, 4, 5, 6]
tailSet(4) : [4, 5, 6]
tailSet(4, false) : [5, 6]

subSet(e1, bv1, e2, bv2)

Renvoie les éléments entre e1 (inclus par défaut) et e2 (exclus par défaut). bv1 par défaut true, bv2 par défaut false.

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(2);
        nombres.add(5);
        nombres.add(4);
        nombres.add(6);
        System.out.println("TreeSet : " + nombres);

        System.out.println("subSet(4, 6) : " + nombres.subSet(4, 6));
        System.out.println("subSet(4, false, 6, true) : " + nombres.subSet(4, false, 6, true));
    }
}

Sortie

TreeSet : [2, 4, 5, 6]
subSet(4, 6) : [4, 5]
subSet(4, false, 6, true) : [5, 6]

Opérations sur les ensembles

Union d'ensembles

Utilisez addAll() pour l'union :

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombresPairs = new TreeSet<>();
        nombresPairs.add(2);
        nombresPairs.add(4);
        System.out.println("TreeSet1 : " + nombresPairs);

        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(1);
        nombres.add(2);
        nombres.add(3);
        System.out.println("TreeSet2 : " + nombres);

        nombres.addAll(nombresPairs);
        System.out.println("Union : " + nombres);
    }
}

Sortie

TreeSet1 : [2, 4]
TreeSet2 : [1, 2, 3]
Union : [1, 2, 3, 4]

Intersection d'ensembles

Utilisez retainAll() :

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombresPairs = new TreeSet<>();
        nombresPairs.add(2);
        nombresPairs.add(4);
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(1);
        nombres.add(2);
        nombres.add(3);

        nombres.retainAll(nombresPairs);
        System.out.println("Intersection : " + nombres);
    }
}

Sortie

Intersection : [2]

Différence d'ensembles

Utilisez removeAll() :

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombresPairs = new TreeSet<>();
        nombresPairs.add(2);
        nombresPairs.add(4);
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(1);
        nombres.add(2);
        nombres.add(3);
        nombres.add(4);

        nombres.removeAll(nombresPairs);
        System.out.println("Différence : " + nombres);
    }
}

Sortie

Différence : [1, 3]

Sous-ensemble

Utilisez containsAll() pour vérifier si un ensemble est un sous-ensemble d'un autre :

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nombres = new TreeSet<>();
        nombres.add(1);
        nombres.add(2);
        nombres.add(3);
        nombres.add(4);
        TreeSet<Integer> nombresPremiers = new TreeSet<>();
        nombresPremiers.add(2);
        nombresPremiers.add(3);

        boolean resultat = nombres.containsAll(nombresPremiers);
        System.out.println("TreeSet2 est-il sous-ensemble de TreeSet1 ? " + resultat);
    }
}

Sortie

TreeSet1 : [1, 2, 3, 4]
TreeSet2 : [2, 3]
TreeSet2 est-il sous-ensemble de TreeSet1 ? true

Autres méthodes de TreeSet

Méthode	Description
`clone()`	Crée une copie du TreeSet
`contains()`	Recherche un élément et renvoie un booléen
`isEmpty()`	Vérifie si le TreeSet est vide
`size()`	Renvoie la taille du TreeSet
`clear()`	Supprime tous les éléments

Pour plus de détails, consultez la documentation officielle Java TreeSet.

TreeSet vs HashSet

TreeSet stocke les éléments dans un ordre (implémente SortedSet), contrairement à HashSet
TreeSet fournit des méthodes de navigation (first(), last(), headSet(), etc.) car il implémente NavigableSet
HashSet est plus rapide pour les opérations de base (add, remove, contains, size)

TreeSet avec Comparator

Pour personnaliser l'ordre, créez une classe comparateur :

import java.util.TreeSet;
import java.util.Comparator;

class Main {
    public static void main(String[] args) {
        TreeSet<String> animaux = new TreeSet<>(new ComparateurPersonnalise());
        animaux.add("Chien");
        animaux.add("Zèbre");
        animaux.add("Chat");
        animaux.add("Cheval");
        System.out.println("TreeSet : " + animaux);
    }

    static class ComparateurPersonnalise implements Comparator<String> {
        @Override
        public int compare(String a1, String a2) {
            int valeur = a1.compareTo(a2);
            // Tri en ordre inverse
            if (valeur > 0) return -1;
            else if (valeur < 0) return 1;
            else return 0;
        }
    }
}

Sortie