devstory

Le Tutoriel de Java TreeSet

  1. TreeSet
  2. Comment TreeSet stocke-t-il les données?
  3. Examples
  4. TreeSet et l'élément null

1. TreeSet

Dans cet article, nous découvrons la classe TreeSet, qui est une implémentation de l'interface NavigableSet et se situe dans Java Collection Framework.
public class TreeSet<E> extends AbstractSet<E>
                    implements NavigableSet<E>, Cloneable, java.io.Serializable
En règle générale, dans cet article, nous apprenons les caractéristiques de TreeSet et la manière dont il stocke les éléments. Vous devez apprendre les notions basiques de Set avant de lire cet article.
Les caractéristiques de TreeSet:
Set<E>
SortedSet<E>
NavigableSet<E>
TreeSet<E>
Les éléments dupliqués ne sont pas autorisés. Si vous ajoutez intentionnellement un élément dupliqué, cette action sera ignorée.
Au maximum un élément null est autorisé.
Au maximum un élément null est autorisé et uniquement si un Comparator approprié est fourni.
L'ordre des éléments n'est pas garanti.
Les éléments sont classés dans l'ordre croissant selon leur ordre naturel ou par un Comparator fourni.
Hériter des caractéristiques de l'interface SortedSet. Tous les éléments de TreeSet doivent être de type Comparable ou vous devez fournir un Comparator pour TreeSet comparant les éléments. Sinon, ClassCastException sera levée. Comparator est fourni au moment où l'objet TreeSet est créé via l'un de ses constructeurs.
Les constructeurs de TreeSet:
TreeSet​(Comparator<? super E> comparator)   

// Using the same ordering as the specified sortedSet.
TreeSet​(SortedSet<E> sortedSet)    

TreeSet()     

TreeSet​(Collection<? extends E> c)

2. Comment TreeSet stocke-t-il les données?

TreeSet<E> gère un objet TreeMap<E,Object> interne - internalMap. Toutes les opérations sur TreeSet sont effectuées sur internalMap. De plus, comme nous le savons, TreeMap stocke ses données dans une structure arborescente, d'où le nom de TreeSet.
Afin de faciliter la compréhension, en observant le code source de la classe java.util.TreeSet, vous verrez qu'il agit comme un délégué de l'objet TreeMap qu'il gère.
java.util.TreeSet class
public class TreeSet<E> extends AbstractSet<E>
                   implements NavigableSet<E>, Cloneable, java.io.Serializable {

    private static final Object PRESENT = new Object();
    
    private transient TreeMap<E,Object> internalMap;
    
    public boolean add(E e) {
        return this.internalMap.put(e, PRESENT)==null;
    }
    
    public boolean remove(Object o) {
        return this.internalMap.remove(o)==PRESENT;
    }
    
    public void clear() {
        this.internalMap.clear();
    }
    
     public E first() {
        return this.internalMap.firstKey();
    }
     
    public E last() {
        return this.internalMap.lastKey();
    }
    // Other methods..
}
TreeMap stocke ses données selon une structure arborescente, celle-ci est expliquée dans l'article ci-dessous. Si vous y êtes intéressé, veuillez le consulter.

3. Examples

Comme nous le savons tous, la classe Integer implémente l'interface Comparable, de sorte que les objets Integer peuvent être comparés les uns aux autres. TreeSet avec des éléments de type Integer n'a pas besoin d'un Comparator.
TreeSetEx1.java
package org.o7planning.treeset.ex;

import java.util.TreeSet;

public class TreeSetEx1 {

    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        //
        set.add(5);
        set.add(3);
        set.add(9);
        set.add(7);
        set.add(1);
        set.add(11);

        System.out.println(set);
    }
}
Output:
[1, 3, 5, 7, 9, 11]
Exemple: Utiliser un Comparator personnalisé pour inverser l'ordre des éléments.
TreeSet_reverseOrder_ex1.java
package org.o7planning.treeset.ex;

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

public class TreeSet_reverseOrder_ex1 {

    public static void main(String[] args) {
        Comparator<Integer> reverseOrderComparator = Comparator.reverseOrder();
        
        TreeSet<Integer> set = new TreeSet<>(reverseOrderComparator);
        //
        set.add(5);
        set.add(3);
        set.add(9);
        set.add(7);
        set.add(1);
        set.add(11);

        System.out.println(set);
    }
}
Output:
[11, 9, 7, 5, 3, 1]
Voir plus d'exemples sur l'utilisation de Comparator personnalisé dans TreeSet et comment naviguer et rechercher des éléments.

4. TreeSet et l'élément null

TreeSet n'autorise l'élément null que s'il est fourni avec un Comparator qui prend en charge la comparaison de l'élément null avec d'autres éléments.
TreeSet_nullElement_ex1.java
package org.o7planning.treeset.ex;

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

public class TreeSet_nullElement_ex1 {

    public static void main(String[] args) {
        // Comparator.nullsFirst
        // Comparator.nullsLast
        Comparator<String> comparator = Comparator.nullsFirst(Comparator.naturalOrder());

        // Create a SortedSet object.
        SortedSet<String> map = new TreeSet<String>(comparator);

        map.add("B");
        map.add("A");
        map.add("F");
        map.add(null);
        map.add("D");
        map.add("E");

        System.out.println(map);
    }
}
Output:
[null, A, B, D, E, F]
Exemple: Ecrire un Comparator personnalisé qui prend en charge la comparaison d'un élément null avec d'autres éléments :
TreeSet_nullElement_ex2.java
package org.o7planning.treeset.ex;

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

public class TreeSet_nullElement_ex2 {

    public static void main(String[] args) {
        Comparator<String> comparator = new StringNullComparator();

        // Create a SortedSet object.
        SortedSet<String> map = new TreeSet<String>(comparator);

        map.add("B");
        map.add("A");
        map.add("F");
        map.add(null);
        map.add("D");
        map.add("E");

        System.out.println(map);
    }
}

// The comparator supports null comparison.
class StringNullComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        if (o1 == o2) {
            return 0; // o1 = o2
        }
        if (o1 == null) {
            return -1; // o1 < o2
        }
        if (o2 == null) {
            return 1; // o1 > o2
        }
        return o1.compareTo(o2);
    }
}
Output:
[null, A, B, D, E, F]

Tutoriels de Java Collections Framework

Show More

Articles les plus récents

Show More