Java TreeSet

Ensemble d'arbres Java

Dans ce didacticiel, nous allons découvrir la classe Java TreeSet et ses différentes opérations et méthodes à l'aide d'exemples.

Le TreeSet La classe du framework de collections Java fournit la fonctionnalité d'une structure de données arborescente.

Il étend l'interface NavigableSet.

Créer un TreeSet

Afin de créer un ensemble d'arbres, nous devons importer le java.util.TreeSet paquet d'abord.

Une fois que nous avons importé le package, voici comment nous pouvons créer un TreeSet en Java.


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

Ici, nous avons créé un TreeSet sans aucun argument. Dans ce cas, les éléments de TreeSet sont triés naturellement (ordre croissant).

Cependant, nous pouvons personnaliser le tri des éléments en utilisant le Comparator interface. Nous en apprendrons plus tard dans ce tutoriel.

Méthodes de TreeSet

Le TreeSet La classe fournit diverses méthodes qui nous permettent d'effectuer diverses opérations sur l'ensemble.

Insérer des éléments dans TreeSet

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

Par exemple,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {

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

        // Using the add() method
        evenNumbers.add(2);
        evenNumbers.add(4);
        evenNumbers.add(6);
        System.out.println("TreeSet: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);

        // Using the addAll() method
        numbers.addAll(evenNumbers);
        System.out.println("New TreeSet: " + numbers);
    }
}

Sortie

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

Accéder aux éléments TreeSet

Pour accéder aux éléments d'un arbre, on peut utiliser le iterator() méthode. Pour utiliser cette méthode, nous devons importer java.util.Iterator forfait. Par exemple,

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

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

        // Calling iterator() method
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("TreeSet using Iterator: ");
        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Sortie

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

Supprimer des éléments

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

Par exemple,

import java.util.TreeSet;

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

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        // Using the removeAll() method
        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

Sortie

TreeSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Depuis le TreeSet la classe implémente NavigableSet , il fournit diverses méthodes pour naviguer sur les éléments de l'arborescence.

1. Méthodes first() et last()

first() - renvoie le premier élément de l'ensemble
last() - renvoie le dernier élément de l'ensemble

Par exemple,

import java.util.TreeSet;

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

        // Using the first() method
        int first = numbers.first();
        System.out.println("First Number: " + first);

        // Using the last() method
        int last = numbers.last();
        System.out.println("Last Number: " + last);
    }
}

Sortie

TreeSet: [2, 5, 6]
First Number: 2
Last Number: 6

2. méthodes plafond(), plancher(), supérieur() et inférieur()

supérieur(élément) - Renvoie l'élément le plus bas parmi les éléments supérieurs au element spécifié .^®
inférieur(élément) - Renvoie le plus grand élément parmi les éléments inférieurs au element spécifié .
plafond (élément) - Renvoie l'élément le plus bas parmi les éléments qui sont supérieurs à l'élément spécifié . Si l'élément passé existe dans un ensemble d'arbres, il renvoie le element passé en argument.
sol(élément) - Renvoie le plus grand élément parmi les éléments inférieurs au element spécifié . Si l'élément passé existe dans un ensemble d'arbres, il renvoie le element passé en argument.

Par exemple,

import java.util.TreeSet;

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

        // Using higher()
        System.out.println("Using higher: " + numbers.higher(4));

        // Using lower()
        System.out.println("Using lower: " + numbers.lower(4));

        // Using ceiling()
        System.out.println("Using ceiling: " + numbers.ceiling(4));

        // Using floor()
        System.out.println("Using floor: " + numbers.floor(3));

    }
}

Sortie

TreeSet: [2, 4, 5, 6]
Using higher: 5
Using lower: 2
Using ceiling: 4
Using floor: 2

3. Méthodes pollfirst() et pollLast()

pollFirst() - renvoie et supprime le premier élément de l'ensemble
pollLast() - renvoie et supprime le dernier élément de l'ensemble

Par exemple,

import java.util.TreeSet;

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

        // Using pollFirst()
        System.out.println("Removed First Element: " + numbers.pollFirst());

        // Using pollLast()
        System.out.println("Removed Last Element: " + numbers.pollLast());

        System.out.println("New TreeSet: " + numbers);
    }
}

Sortie

TreeSet: [2, 4, 5, 6]
Removed First Element: 2
Removed Last Element: 6
New TreeSet: [4, 5]

4. Méthodes headSet(), tailSet() et subSet()

headSet(element, booleanValue)

Le headSet() La méthode renvoie tous les éléments d'un ensemble d'arbres avant l'élément spécifié (qui est passé en argument).

La booleanValue paramètre est facultatif. Sa valeur par défaut est false .

Si true est passé en tant que booleanValue , la méthode renvoie tous les éléments avant l'élément spécifié, y compris l'élément spécifié.

Par exemple,

import java.util.TreeSet;

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

        // Using headSet() with default boolean value
        System.out.println("Using headSet without boolean value: " + numbers.headSet(5));

        // Using headSet() with specified boolean value
        System.out.println("Using headSet with boolean value: " + numbers.headSet(5, true));
    }
}

Sortie

TreeSet: [2, 4, 5, 6]
Using headSet without boolean value: [2, 4]
Using headSet with boolean value: [2, 4, 5]

tailSet(element, booleanValue)

Le tailSet() La méthode renvoie tous les éléments d'un ensemble d'arbres après l'élément élément spécifié (qui est passé en paramètre) incluant l'élément spécifié .

La booleanValue paramètre est facultatif. Sa valeur par défaut est true .

Si false est passé en tant que booleanValue , la méthode renvoie tous les éléments après l'élément élément spécifié sans inclure l'élément spécifié .

Par exemple,

import java.util.TreeSet;

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

        // Using tailSet() with default boolean value
        System.out.println("Using tailSet without boolean value: " + numbers.tailSet(4));

        // Using tailSet() with specified boolean value
        System.out.println("Using tailSet with boolean value: " + numbers.tailSet(4, false));
    }
}

Sortie

TreeSet: [2, 4, 5, 6]
Using tailSet without boolean value: [4, 5, 6]
Using tailSet with boolean value: [5, 6]

sous-ensemble(e1, bv1, e2, bv2)

Le subSet() la méthode renvoie tous les éléments entre e1 et e2 y compris e1 .

Le bv1 et bv2 sont des paramètres facultatifs. La valeur par défaut de bv1 est true , et la valeur par défaut de bv2 est false .

Si false est passé comme bv1 , la méthode renvoie tous les éléments entre e1 et e2 sans inclure e1 .

Si true est passé comme bv2 , la méthode renvoie tous les éléments entre e1 et e2 , y compris e1 .

Par exemple,

import java.util.TreeSet;

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

        // Using subSet() with default boolean value
        System.out.println("Using subSet without boolean value: " + numbers.subSet(4, 6));

        // Using subSet() with specified boolean value
        System.out.println("Using subSet with boolean value: " + numbers.subSet(4, false, 6, true));
    }
}

Sortie

TreeSet: [2, 4, 5, 6]
Using subSet without boolean value: [4, 5]
Using subSet with boolean value: [5, 6]

Définir les opérations

Les méthodes du TreeSet La classe peut également être utilisée pour effectuer diverses opérations d'ensemble.

Union d'ensembles

Pour réaliser l'union entre deux ensembles, on utilise le addAll() méthode. Par exemple,

import java.util.TreeSet;;

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

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

        // Union of two sets
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);

    }
}

Sortie

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

Intersection d'ensembles

Pour effectuer l'intersection entre deux ensembles, on utilise le retainAll() méthode. Par exemple,

import java.util.TreeSet;;

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

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

        // Intersection of two sets
        numbers.retainAll(evenNumbers);
        System.out.println("Intersection is: " + numbers);
    }
}

Sortie

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Intersection is: [2]

Différence des ensembles

Pour calculer la différence entre les deux ensembles, nous pouvons utiliser le removeAll() méthode. Par exemple,

import java.util.TreeSet;;

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

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

        // Difference between two sets
        numbers.removeAll(evenNumbers);
        System.out.println("Difference is: " + numbers);
    }
}

Sortie

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Difference is: [1, 3]

Sous-ensemble d'un ensemble

Pour vérifier si un ensemble est un sous-ensemble d'un autre ensemble ou non, on utilise le containsAll() méthode. Par exemple,

import java.util.TreeSet;

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

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

        // Check if primeNumbers is subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is TreeSet2 subset of TreeSet1? " + result);
    }
}

Sortie

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
Is TreeSet2 subset of TreeSet1? True

Autres méthodes de TreeSet

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

Pour en savoir plus, visitez Java TreeSet (documentation officielle de Java).

TreeSet Vs. Ensemble de hachage

Le TreeSet ainsi que le HashSet implémente le Set interface. Cependant, il existe quelques différences entre eux.

Contrairement à HashSet , éléments en TreeSet sont stockés dans un certain ordre. C'est parce que TreeSet implémente le SortedSet interface également.
TreeSet fournit quelques méthodes pour faciliter la navigation. Par exemple, first() , last() , headSet( ), tailSet() , etc. C'est parce que TreeSet implémente également le NavigableSet interface.
HashSet est plus rapide que le TreeSet pour les opérations de base telles que l'ajout, la suppression, le contenu et la taille.

Comparateur TreeSet

Dans tous les exemples ci-dessus, les éléments de l'ensemble d'arbres sont triés naturellement. Cependant, nous pouvons également personnaliser l'ordre des éléments.

Pour cela, nous devons créer notre propre classe de comparaison en fonction des éléments d'un ensemble d'arbres qui sont triés. Par exemple,

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

class Main {
    public static void main(String[] args) {

        // Creating a tree set with customized comparator
        TreeSet<String> animals = new TreeSet<>(new CustomComparator());

        animals.add("Dog");
        animals.add("Zebra");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("TreeSet: " + animals);
    }

    // Creating a comparator class
    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String animal1, String animal2) {
            int value =  animal1.compareTo(animal2);

            // elements are sorted in reverse order
            if (value > 0) {
                return -1;
            }
            else if (value < 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

Sortie