Interface Comparable

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 72 sur 110.

Alors que == vous indique si deux objets sont égaux, vous avez parfois besoin de savoir lequel vient en premier. L'interface Comparable permet de trier vos objets en définissant un ordre naturel.

Pour rendre une classe comparable, implémentez Comparable<T> et redéfinissez la méthode compareTo. Cette méthode renvoie un nombre négatif si this vient avant other, zéro s'ils sont égaux, et un nombre positif si this vient après :

class Student implements Comparable<Student> {
  String name;
  int grade;
  
  Student(this.name, this.grade);
  
  @override
  int compareTo(Student other) {
    return grade.compareTo(other.grade);
  }
}

void main() {
  var students = [
    Student('Alice', 85),
    Student('Bob', 92),
    Student('Carol', 78),
  ];
  
  students.sort();
  
  for (var s in students) {
    print('${s.name}: ${s.grade}');
  }
  // Carol: 78, Alice: 85, Bob: 92
}

Une fois que votre classe implémente Comparable, vous pouvez utiliser sort() sans fournir de comparateur personnalisé. Les types numériques et de chaînes de caractères intégrés implémentent déjà Comparable, c'est pourquoi grade.compareTo(other.grade) fonctionne directement.

Pour l'ordre décroissant, inversez simplement la comparaison en échangeant les objets ou en inversant le signe du résultat :

@override
int compareTo(Student other) {
  return other.grade.compareTo(grade);  // Décroissant
}

Défi

Facile

Construisons un système de gestion de tâches où les tâches peuvent être triées par leur niveau de priorité ! Vous allez créer une classe Task qui implémente l'interface Comparable, permettant à une liste de tâches d'être automatiquement triée de la priorité la plus élevée à la plus basse.

Vous organiserez votre code en deux fichiers :

task.dart : Créez une classe Task qui représente un élément à faire avec un name (String) et une priority (int, où les nombres plus élevés signifient une priorité plus élevée). Votre tâche doit implémenter Comparable<Task> de sorte que, lors du tri, les tâches apparaissent par ordre décroissant de priorité (la priorité la plus élevée en premier). Remplacez également toString() pour retourner le format : [name] (Priority: [priority])
main.dart : Importez votre fichier de tâche et démontrez comment l'interface Comparable permet un tri automatique. Créez une liste contenant ces quatre tâches :
- 'Write report' avec la priorité 2
- 'Fix critical bug' avec la priorité 5
- 'Update documentation' avec la priorité 1
- 'Review code' avec la priorité 3
Affichez Before sorting:, puis affichez chaque tâche. Triez la liste en utilisant sort(), affichez une ligne vide, puis affichez After sorting: suivi de chaque tâche à nouveau.

Parce que votre classe Task implémente Comparable, vous pouvez appeler sort() directement sur la liste sans fournir de comparateur personnalisé. Les tâches s'organiseront automatiquement en fonction de votre implémentation de compareTo !

Sortie attendue :

Before sorting:
Write report (Priority: 2)
Fix critical bug (Priority: 5)
Update documentation (Priority: 1)
Review code (Priority: 3)

After sorting:
Fix critical bug (Priority: 5)
Review code (Priority: 3)
Write report (Priority: 2)
Update documentation (Priority: 1)

Aide-mémoire

L'interface Comparable permet aux objets de définir un ordre naturel pour le tri. Implémentez Comparable<T> et redéfinissez la méthode compareTo.

La méthode compareTo retourne :

Un nombre négatif si this vient avant other
Zéro s'ils sont égaux
Un nombre positif si this vient après other

Implémentation de base (ordre croissant) :

class Student implements Comparable<Student> {
  String name;
  int grade;
  
  Student(this.name, this.grade);
  
  @override
  int compareTo(Student other) {
    return grade.compareTo(other.grade);
  }
}

Une fois qu'une classe implémente Comparable, vous pouvez utiliser sort() sans comparateur personnalisé :

var students = [
  Student('Alice', 85),
  Student('Bob', 92),
  Student('Carol', 78),
];

students.sort();  // Utilise automatiquement compareTo

Pour un ordre décroissant, inversez la comparaison :

@override
int compareTo(Student other) {
  return other.grade.compareTo(grade);  // Décroissant
}

Essayez vous-même

import 'task.dart';

void main() {
  // TODO: Créer une liste d'objets Task avec les éléments suivants :
  // - 'Write report' avec la priorité 2
  // - 'Fix critical bug' avec la priorité 5
  // - 'Update documentation' avec la priorité 1
  // - 'Review code' avec la priorité 3
  
  List<Task> tasks = [
    // TODO: Ajouter les quatre tâches ici
  ];
  
  // TODO: Afficher "Before sorting:"
  // TODO: Afficher chaque tâche de la liste
  
  // TODO: Trier la liste en utilisant sort()
  
  // TODO: Afficher une ligne vide
  
  // TODO: Afficher "After sorting:"
  // TODO: Afficher chaque tâche de la liste triée
}