Après l’égalité, il est naturel de parler d’ordre entre des éléments, si deux éléments ne sont pas égaux ⇒ comment situer l’un à l’autre
En Java, on peut ordonner des instances d’une classe donnée en lui faisant implémenter la classe Comparable, ou alors utiliser un comparateur.
L’interface Comparable
L’interface (fonctionnelle) Comparable permet d’attacher une notion d’ordre à une classe:
public interface Comparable<T> {
// Compare this et that
int compareTo(T that);
}Elle est une interface générique car si l’on fait pas, on doit comparer à une instance de Object, et il faut par conséquent faire un transtypage. Mais si les deux objets ne sont pas de même type, on ne sait pas quelle valeur entière retourner.
Cela fait par contre que quand on implémente cette interface, on est obligé de paramétrer cette interface avec la classe qui l’implémente.
L’interface Comparator
Permet de comparer deux valeurs (sans comparer this).
donc nous avons à peu près:
public interface Comparator<T> {
int compare(T o1, T o2);
}
/* ... */
int compare(Object o1, Object o2) {
return o1.compareTo(o2);
}
/* ... */
int compareTo(Object that) {
return compare(this, that);
}Comparable et Comparator
On peut donc utiliser ces interfaces comme lambdas, comme on l’a vu avec les collections, pour les trier
List<MyType> list = new ArrayList();
/* ... */
list.sort(MyType::compare) // (a, b) -> MyType.compare(a, b);On peut aussi avoir ce comparateur dans le constructeur de TreeSet pour pouvoir dire comment cet ensemble est sensé comparer les éléments.