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() {
}
public String lastName() {
}
public boolean equals(Object o) {
}
public int compareTo(Object o) {
}
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 ) {
}
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() );
}
}