La classe TreeMap est une implémentation de l'interface SortedMap et une extension de la classe AbstractMap.

// extrait de la classe TreeMap
public class TreeMap extends AbstractMap
         implements SortedMap, Cloneable, java.io.Serializable {
  //...
}

Cette classe garantit que la collection Map sera triée selon un ordre croissant, conformément à l'ordre naturel des clés ou à l'aide d'un comparateur fourni au moment de la création de l'objet TreeMap.

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

Il existe quatre constructeurs permettant d'instancier la classe TreeMap. Le constructeur par défaut (TreeMap()) initialise l'objet en fondant son mode de tri sur l'ordre naturel des éléments. Toutefois, un autre constructeur permet de spécifier un comparateur afin d'effectuer le tri des paires clé/valeur de l'objet TreeMap.

// par défaut
TreeMap associations = new TreeMap();
// comparateur
Comparator comparateur = new Comparateur();
TreeMap associations = new TreeMap(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 TreeMap défini sans comparateur, utilise les méthodes compareTo() et equals() des objets contenus dans cet objet Map.

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

Les deux autres constructeurs acceptent comme argument un objet de type Map ou SortedMap, destinée à initialiser la nouvelle instance. Chaque paire clé/valeur des collections spécifiées sera copiée au sein de l'objet TreeMap. Dans le premier cas, la collection sera triée selon l'ordre naturel de ses clés, dans le second, conformément à l'ordonnancement de l'objet SortedMap indiqué.

// initialisation avec un objet Map
Map collection = new HashMap();
collection.put(cle, valeur);
//...
TreeMap associations = new TreeMap(collection);

// initialisation avec un objet SortedMap
SortedMap collection = new TreeMap(comparateur);
collection.put(cle, valeur);
//...
TreeMap associations = new TreeMap(collection);

La classe TreeMap contient des méthodes d'ajout (put() et putAll()), de suppression (remove() et clear()), de vérification de présence (isEmpty(), containsKey() et containsValue()), d'information (size()) et d'extraction (get()).

La classe TreeMap fournit deux méthodes firstKey() et lastKey(), chargées respectivement de récupérer dans un objet Map la première clé, soit la plus petite, et la dernière clé, soit la plus grande. La comparaison entre les clés est assurée par l'ordre naturel ou par le comparateur fourni lors de l'instanciation de l'objet.

Object premier = associations.fisrtKey();

Object dernier = associations.lastKey();

Le comparateur associé à la collection TreeMap est accessible via la méthode comparator().

Comparator comparateur = associations.comparator();

En outre, la collection SortedMap comporte plusieurs méthodes capables d'extraire la totalité ou une partie des entrées, ou seulement des clés ou des valeurs stockées dans l'objet TreeMap. Les méthodes headMap(), trailMap(), subMap(), keySet() et values() permettent toutes d'obtenir une vue spécifique de la collection TreeMap.

TreeMap associations = new TreeMap();
// remplissage de la collection...
// Toutes les clés sont stockées dans la collection Set
Set cles = associations.keySet();
// Toutes les valeurs sont stockées dans l'objet Collection.
Collection valeurs = associations.values();

Les méthodes headMap() et tailMap() retournent seulement les entrées de l'objet TreeMap, dont les clés sont respectivement, strictement inférieures et supérieures ou égales à l'objet passé en argument. La méthode subMap() extrait un intervalle d'entrées, dont les clés sont comprises entre la valeur du premier argument incluse et la valeur du second argument exclue.

SortedMap partieInferieure = associations.headMap(valeur);

SortedMap partieSuperieure = associations.tailMap(valeur);

SortedMap partie = associations.subMap(valInf, valSup);
Exemple [voir]
import java.util.Iterator;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.Comparator;

public class CollectionSortedMap {
  static final Comparator ORDRE_REALISATEUR = new CompRealisateur();
  static final Comparator ORDRE_ANNEE = new CompAnnee();

  public static void main(String[] args) {
    TreeMap associations = new TreeMap();
    associations.put(new Video("Le jour le plus long", "Ken Annakin", 1962), 
                     "Le débarquement en Normandie par les troupes alliées " 
                   + "le 6 juin 1944. Un casting prestigieux pour un film " 
                   + "de guerre d'anthologie.");
    associations.put(new Video("Un pont trop loin", "Richard Attenborough", 1977), 
                     "La plus grande opération aéroportée sur les ponts entre " 
                   + "la France et l'Allemagne, doit précipiter la chute de "
                   + "l'Allemagne nazie.");
    associations.put(new Video("Platoon", "Oliver Stone", 1986), 
                     "Ce film choc sur la guerre du Vietnam, met en "
                   + "scène un peloton du 25eme régiment d'infanterie "
                   + "gangréné par des luttes intestinales.");
    associations.put(new Video("Full metal jacket", "Stanley Kubrik", 1987), 
                   + ""Cette épopée de la guerre du Vietnam raconte "
                   + "l'évolution de jeunes Marines durant un entraînement "
                   + "impitoyable et jusqu'à une réalité sanglante des "
                   + "combats lors des offensives du tet à Hue.");
    associations.put(new Video("La ligne rouge", "Terrence Malick", 1998), 
                     "Ce film décrit la bataille de Guadalcanal et ses "
                   + "terribles affrontements entre soldats américains "
                   + "et japonais dans une île aux paysages paradisiaques.");
    associations.put(new Video("The patriot", "Roland Emmerich", 2000), 
                   + ""Lors de la guerre d'indépendance américaine en 1776, "
                   + "un père tente de sauvegarder ses enfants de la barbarie "
                   + "d'une guerre fratricide, mais ne peut empêcher d'y être "
                   + "plongé malgrè lui.");
    System.out.println("Tri par titre :");
    afficherEntrees(associations); 

    TreeMap associationsR = new TreeMap(ORDRE_REALISATEUR);
    associationsR.putAll(associations);
    System.out.println("\nTri par réalisateur :");
    afficherEntrees(associationsR);

    TreeMap associationsA = new TreeMap(ORDRE_ANNEE);
    associationsA.putAll(associations);
    System.out.println("\nTri par année :");
    afficherEntrees(associationsA);

    Video article = new Video("Platoon", "Oliver Stone", 1986);
    if(associations.containsKey(article))
        System.out.println("La vidéo Platoon a été trouvée !");

    System.out.println("\nRécupération des vidéos strictement inférieures :");
    SortedMap selectInf = 
            associations.headMap(article);
    afficherEntrees(selectInf);
    System.out.println("\nRécupération des vidéos supérieures ou égales :");
    SortedMap selectSup = 
            associations.tailMap(article);
    afficherEntrees(selectSup);
  }

  public static void afficherEntrees(SortedMap assoc){
    Set ensemble = assoc.keySet();
    int taille = assoc.size();
    Iterator iterateur = ensemble.iterator();
    while(iterateur.hasNext()){
      Object o = iterateur.next();
      System.out.println(o.toString() + " : " + assoc.get(o));
    }
  }
}

// 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();
  }
}