précédent | suivant | table des matières

TreeSet

Les données stockées dans un TreeSet sont représentées dans un TreeMap, ou suivant le constructeur plus généralement dans un SortedMap.
Un TreeMap est un arbre binaire équilibré par la technique rouge-noir.

public class TreeSet<E>  extends AbstractSet<E> 
                         implements SortedSet<E>, Cloneable, java.io.Serializable {
   private transient SortedMap<E,Object> m; /// L'arbre binaire des données
   private transient Set<E> keySet; // La vue clé de cet arbre binaire
   // valeur "bidon" associée à un objet stocké dans le TreeMap
    private static final Object PRESENT = new Object();
    ...

1 Les constructeurs :

private TreeSet(SortedMap<E,Object> m) {
   this.m = m;
   keySet = m.keySet();
}

public TreeSet() {
   this(new TreeMap<E,Object>());
}

public TreeSet(Comparator<? super E> c) {
   this(new TreeMap<E,Object>(c));
}

public TreeSet(Collection<? extends E> c) {
   this();
   addAll(c);
}

public TreeSet(SortedSet<E> s) {
   this(s.comparator());
   addAll(s);
}

2 Les méthodes :

Les méthodes se résument toutes à un appel de la méthode correspondante de la classe TreeMap. Exemples :

la méthode add ajoute un couple (o,PRESENT), elle utilise la méthode put de TreeMap, qui retourne null si l'objet était absent du TreeMap avant ajout.
```
public boolean add(E o) {
   return m.put(o, PRESENT)==null;
}
```
la méthode remove enlève un couple (o, PRESENT), elle utilise la méthode remove de TreeMap, qui retourne la valeur associée à la clé o, si celle-ci était présente dans le TreeMap, et null sinon.
```
public boolean remove(Object o) {
   return m.remove(o)==PRESENT;<
}
```
la méthode clear vide le TreeSet.
```
public void clear() {
   m.clear();
}
```

les méthodes subSet, headSet et tailSet :

public SortedSet<E> subSet(E fromElement, E toElement) {
   return new TreeSet<E>(m.subMap(fromElement, toElement));
}

Retourne l'ensemble des éléments supérieurs ou égaux à fromElement et inférieurs strictement à toElement.

public SortedSet<E> headSet( E toElement) {
   return new TreeSet<E>(m.subMap(fromElement, toElement));
}

Retourne l'ensemble des éléments strictement inférieurs à toElement.

public SortedSet<E> tailSet(E fromElement) {
   return new TreeSet<E>(m.tailMap(fromElement));
}

Retourne l'ensemble des éléments supérieurs ou égaux à fromElement.

les méthodes first et last :

public E first() {
   return m.firstKey();
}

public E last() {
   return m.lastKey();
}

la méthode contains :

public boolean contains(Object o) {
   return m.containsKey(o);
}

haut de la page