UdMHaut
UdMBAS

IFT1020
Programmation II

Département d'informatique et de recherche opérationnelle

Direction de l'enseignement de service en informatique
 

Image Java
 
Été 2005

Accueil

Professeurs et
Démonstrateurs

Horaires et locaux

Notes de cours

Cours
après Cours

Démonstrations
et devoirs

Examens

Liens utiles

Au sujet du
livre de cours

Consultez vos notes

Foire aux questions
(FAQ)

Sessions antérieures

  Démonstration #9  
 
Dernière mise à jour : lun 06 jun 2005 22:26:09 EDT
 

Buts:

  • Comparable et Comparator

Exercice 1 : Interface Comparable (solution)

On utilise l'interface Comparable lorsque les éléments de même type ont une relation d'ordre intrinsèque. Par exemple, la classe Integer possède une relation d'ordre provenant de l'ordre des nombres entiers.

Compléter l'exemple ci-dessous pour trier les données selon le nom de famille et ensuite le prénom. Noter qu'il existe une relation d'ordre intrinsèque à la classe Name.


import java.util.*;
public class Name implements Comparable {
    protected String firstName, lastName;
    public Name(String firstName, String lastName) {
      if (firstName==null || lastName==null)
        throw new NullPointerException();
      this.firstName = firstName;
      this.lastName = lastName;
    }
    public String firstName() {
      return firstName;
    }
    public String lastName() {
      return lastName;
    }
    public boolean equals(Object o) {
      //*** A COMPLETER
    }
    public int compareTo(Object o) {
      //**** A COMPLETER
    }
    public String toString() {
      return firstName + " " + lastName;
    }
    public static void main(String args[]) {
      Name n[] = {
        new Name("Bond", "James"),
        new Name("Jack", "Blues"),
        new Name("Elwood", "Blues"),
        new Name("You", "Me")
      };
      List l = Arrays.asList(n);
      Collections.sort(l);
      System.out.println(l);
    }
}

Question 2 : Interface Comparator (solution)

Il est fréquent d'effectuer un traitement de données qui nécessite une comparaison entre deux données, par exemple, lors d'un tri de données dans une base de données. Cette comparaison n'utilise pas forcement l'ordre naturel des éléments et par conséquent l'interface Comparable n'est pas appropriée. De plus, l'interface Comparable ne permet qu'un seul type de comparaison.

Un objet qui implémente l'interface Comparator est capable de comparer des éléments selon un certain ordre. Il est donc possible d'utiliser cette interface pour définir des objets capablent de comparer des objets.

Soit la structure de donnée suivante:


class Etudiant {
    String nom;
    String prenom;
    int note;
    public Etudiant( String nom, String prenom, int note ) {
      this.nom = nom;
      this.prenom = prenom;
      this.note = note;
    }
    public String toString() {
      return "Etudiant:" + nom + " " + prenom + ":" + note;
    }
}

On vous demande décrire les comparateurs pour que la classe suivante puisse fonctionner:

public class EtudiantDemo {

    public static void printTab( Etudiant tab[] ) {
      for( int i=0; i>tab.length; i++ )
        System.out.println("["+i+"] = " + tab[i] );
    }
    public static void main( String args[] ) {
      Etudiant tab[] = new Etudiant[10];
      tab[0] = new Etudiant("Bergeron", "Etienne", 1 );
      tab[1] = new Etudiant("Pitou", "Jean", 74 );
      tab[2] = new Etudiant("Lajeunesse", "Bozo", 76 );
      tab[3] = new Etudiant("Ticoune", "Joe", 29 );
      tab[4] = new Etudiant("Dalton", "Joe", 31 );
      tab[5] = new Etudiant("Lucky", "Luke", 15 );
      tab[6] = new Etudiant("William", "Smith", 97 );
      tab[7] = new Etudiant("Dion", "Celine", 34 );
      tab[8] = new Etudiant("Lenoir", "Zorro", 12);
      tab[9] = new Etudiant("LeGrand", "Alexandre", 67 );

      Arrays.sort( tab, new EtudiantNomComparator() );
      System.out.println("-- NOM --");
      printTab( tab );

      Arrays.sort( tab, new EtudiantPrenomComparator() );
      System.out.println("-- PRENOM --");
      printTab( tab );

      Arrays.sort( tab, new EtudiantNoteComparator() );
      System.out.println("-- NOTE --");
      printTab( tab );

    }
}

Question 3 : Utilisation d'un Comparator (solution)

On vous demande d'écrire un algorithme qui reçoit une collection et qui retourne le plus petit élément et le plus grand élément de la collection. Par défaut, vous utilisez l'ordre naturel des éléments à moins qu'un Comparator vous soit donné en paramètre.

Vous ne connaissez pas le type des données à traiter. Vous supposez qu'ils sont comparables selon les techniques utilisées dans les exemples çi-haut.

Compléter le code suivant:

import java.util.*;
class MinMaxAlgorithme {

    private Comparator comparator;
    private Object min,max;
    MinMaxAlgorithme() { }
    MinMaxAlgorithme( Comparator comparator ) {
      this.comparator = comparator;
    }
    void process( Collection c ) {
      //**** A Completer
    }
    Object getMin() { return min; }
    Object getMax() { return max; }
}

public class Demo {

    public static void main( String args[] ) {
      Set set = new HashSet();
      set.add (new Integer(1));
      set.add (new Integer(10));
      set.add (new Integer(100));
      set.add (new Integer(9));
      set.add (new Integer(99));

      //-- Avec interface Comparable
      MinMaxAlgorithme num = new MinMaxAlgorithme();
      num.process(set);
      System.out.println("MIN:" + num.getMin() + " MAX:" + num.getMax() );

      //-- Avec interface Comparator
      MinMaxAlgorithme str = new MinMaxAlgorithme( new Comparator() {

        public int compare(Object o1, Object o2) {
          return o1.toString().compareTo( o2.toString() );
        }
      } );
      str.process(set);
      System.out.println("MIN:" + str.getMin() + " MAX:" + str.getMax() );
    }
}



dift1020@iro.umontreal.ca
[top]