La classe TreeSet est une implémentation de l'interface SortedSet et une extension de la classe AbstractSet. De plus, elle est renforcée par une instance TreeMap.

// extrait de la classe TreeSet
public class TreeSet extends AbstractSet
        implements SortedSet, Cloneable, java.io.Serializable {
  //...
  public TreeSet() {
    this(new TreeMap());
  }
  //...
}

Cette classe garantit que l'ensemble sera trié selon un ordre croissant, conformément à l'ordre naturel des éléments ou à l'aide d'un comparateur fourni au moment de la création de l'objet TreeSet.

Les objets TreeSet assurent de très bonnes performances (log(n)) pour des opérations de base, telles que lors d'ajouts, de suppressions et de vérifications de présence.

Il existe quatre constructeurs permettant d'instancier la classe TreeSet. Le constructeur par défaut (TreeSet()) initialise l'objet en fondant son mode de tri sur l'ordre naturel des éléments. Toutefois, il est possible de spécifier un comparateur pour effectuer le tri des éléments de l'objet TreeSet.

// par défaut
TreeSet ensemble = new TreeSet();
// comparateur
Comparator comparateur = new Comparateur();
TreeSet ensemble = new TreeSet(comparateur);

// classe Comparateur implémentant l'interface Comparator
public class Comparateur implements Comparator {
  public int compare(Object obj1, Object obj2){
    return ((Comparable)obj2).compareTo(obj1);
  }
  public boolean equals(Object obj){
    return this.equals(obj);
  }
}

L'objet Comparator doit être créé par les soins du programmeur. Pour cela, il est nécessaire d'écrire une classe devant implémenter l'interface Comparator, laquelle possède deux méthodes compare() et equals() qui doivent être définies dans cette classe. Un objet TreeSet défini sans comparateur, utilise les méthodes compareTo() et equals() des objets contenus dans cet ensemble.

public interface Comparator {
  public int compare(Object o1, Object o2);
  public boolean equals(Object o);
}

Les deux autres constructeurs acceptent comme argument un objet Collection ou un objet SortedSet, destinée à initialiser la nouvelle instance. Chaque élément des collections spécifiées sera copié au sein de l'objet TreeSet. Dans le premier cas, la collection sera trié selon l'ordre naturel de ses éléments, dans le second, conformément à l'ordonnancement de l'objet SortedSet fourni.

// initialisation avec un objet Collection
Collection collection = new Vector();
collection.add(valeur);
//...
TreeSet ensemble = new TreeSet(collection);

// initialisation avec un objet SortedSet
SortedSet collection = new TreeSet(comparateur);
collection.add(valeur);
//...
TreeSet ensemble = new TreeSet(collection);

La classe TreeSet comprend principalement des méthodes d'ajout (add() et addAll()), de suppression (remove(), removeAll() retainsAll() et clear()) et de vérification de présence (isEmpty(), contains() et containsAll()).

La méthode iterator() retourne un itérateur sur les éléments de l'ensemble. Cet objet Iterator fournira le seul moyen de parcourir l'ensemble sous-jacent.

Iterator valeurs = ensemble.iterator();
while(valeurs.hasNext()){
  System.out.println("Elements : " + valeurs.next());
}

La classe TreeSet fournit deux méthodes first() et last(), chargées respectivement de récupérer dans un ensemble le premier élément, soit le plus petit, et le dernier élément, soit le plus grand. La comparaison entre les éléments est assurée par l'ordre naturel ou par le comparateur spécifié.

Object premier = ensemble.fisrt();

Object dernier = ensemble.last();

Le comparateur de la collection TreeSet est accessible via la méthode comparator().

Comparator comparateur = ensemble.comparator();

En outre, les méthodes toArray() héritées de l'interface Set permettent de renvoyer l'ensemble des éléments contenus dans la collection Set, dans un tableau.

TreeSet ensemble = new TreeSet();
// remplissage de la collection...
Object[] tableau = ensemble.toArray();
// le type d'exécution du tableau retourné 
// est celui du tableau spécifié.
String[] tabString; Object[] tableauString = ensemble.toArray(tabString);

La méthode headSet() retourne seulement les éléments de l'objet TreeSet, qui sont strictement inférieurs à l'objet passé en argument. Ce dernier est exclus de l'objet SortedSet retourné.

SortedSet partie = ensemble.headSet(valeur);
Exemple [voir]
import java.util.TreeSet;
import java.util.Comparator;

public class CollectionTreeSet {
  static final Comparator ORDRE_REALISATEUR = new CompRealisateur();
  static final Comparator ORDRE_ANNEE = new CompAnnee();
  public static void main(String[] args) {
    TreeSet ensemble = new TreeSet();
    ensemble.add(new Video("Le jour le plus long", "Ken Annakin", 1962));
    ensemble.add(new Video("Un pont trop loin", "Richard Attenborough", 1977));
    ensemble.add(new Video("Platoon", "Oliver Stone", 1986));
    ensemble.add(new Video("Full metal jacket", "Stanley Kubrik", 1987));
    ensemble.add(new Video("La ligne rouge", "Terrence Malick", 1998));
    ensemble.add(new Video("The patriot", "Roland Emmerich", 2000));
    System.out.println("Tri par titre :");
    afficherElements(ensemble); 
    TreeSet ensembleR = new TreeSet(ORDRE_REALISATEUR);
    ensembleR.addAll(ensemble);
    System.out.println("\nTri par réalisateur :");
    afficherElements(ensembleR);
    TreeSet ensembleA = new TreeSet(ORDRE_ANNEE);
    ensembleA.addAll(ensemble);
    System.out.println("\nTri par année :");
    afficherElements(ensembleA);
    SortedSet selection = 
                  ensemble.headSet(new Video("Platoon", "Oliver Stone", 1986));
    System.out.println(selection);
  }
  public static void afficherElements(TreeSet ens){
    Iterator valeurs = ens.iterator();
    while(valeurs.hasNext()){
      System.out.println(valeurs.next());
    }
  }
}

// Classe comparatrice CompRealisateur
import java.util.Comparator;

public class CompRealisateur implements Comparator {
  public int compare(Object o1, Object o2){
    if(!(o1 instanceof Video))
      throw new ClassCastException();
    return (((Video)o1).obtenirRealisateur()).compareTo(
                                        ((Video)o2).obtenirRealisateur());
  }
}

// Classe comparatrice CompAnnee
import java.util.Comparator;

public class CompAnnee implements Comparator {
  public int compare(Object o1, Object o2){
    if(!(o1 instanceof Video))
      throw new ClassCastException();
    return (new Integer(((Video)o1).obtenirAnnee())).compareTo(
                                        new Integer(((Video)o2).obtenirAnnee()));
  }
}

//Classe Video implémentant l'interface java.lang.Comparable
import java.util.GregorianCalendar;
import java.util.Calendar;

public class Video implements Comparable {
  private String titre, realisateur;
  private int annee;
  
  public Video(){
    this("Inconnu", "Inconnu", 0);
  }
    public Video (String[] infos) {
      this(infos[0], infos[1], Integer.parseInt(infos[3]));
    }
    public Video (String titre, String realisateur){
      this(titre, realisateur, (new GregorianCalendar()).get(Calendar.YEAR));
    }
  public Video (String titre, String realisateur, String annee){
    this(titre, realisateur, Integer.parseInt(annee));
  }
  public Video (String titre, String realisateur, int annee){
    if (titre == null || realisateur == null)
      throw new NullPointerException();
    this.titre = titre;
    this.realisateur = realisateur;
    this.annee = annee;
  }
  
  public String obtenirTitre(){
    return this.titre;
  }
  public String obtenirRealisateur(){
    return this.realisateur;
  }
  public int obtenirAnnee(){
    return this.annee;
  }

  public void fournirTitre(String titre){
    this.titre = titre;
  }
  public void fournirRealisateur(String realisateur){
    this.realisateur = realisateur;
  }
  public void fournirAnnee(int annee){
    this.annee = annee;
  }
  
  public int hashCode(){
    return annee * titre.hashCode() + realisateur.hashCode();
  }
  
  public boolean equals(Object o){
    if(!(o instanceof Video))
      return false;
    Video v = (Video)o;
    if(this.hashCode() == v.hashCode())
      return true;
    return false;
  }
  
  public int compareTo(Object o){
    if(!(o instanceof Video))
      throw new ClassCastException();
    Video v = (Video)o;
    int comparaison;
    if((comparaison = titre.compareTo(v.obtenirTitre())) != 0)
      return  comparaison;
    else if((comparaison = realisateur.compareTo(v.obtenirRealisateur())) != 0)
      return comparaison;
    else
      return (new Integer(annee)).compareTo(new Integer(v.obtenirAnnee()));
  }
  
  public String toString(){
    StringBuffer res = new StringBuffer("[");
    res.append(titre);
    res.append(", ");
    res.append(realisateur);
    res.append(", ");
    res.append(annee);
    return res.append("]").toString();
  }
}