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 devez parfois 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 chaînes 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 niant le résultat :

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

Défi

Facile

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

Vous organiserez votre code dans deux fichiers :

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

Comme votre classe Task implémente Comparable, vous pouvez appeler directement sort() sur la liste sans fournir de comparateur personnalisé. Les tâches seront automatiquement organisées en fonction de votre implémentation de compareTo !

Résultat attendu :

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)

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 priorité 2
  // - 'Fix critical bug' with priority 5
  // - 'Update documentation' with priority 1
  // - 'Review code' avec priorité 3
  
  List<Task> tasks = [
    // TODO: Ajoutez les quatre tâches ici
  ];
  
  // TODO: Print "Before sorting:"
  // TODO: Affichez chaque tâche de la liste
  
  // TODO: Triez la liste en utilisant sort()
  
  // TODO: Affichez une ligne vide
  
  // TODO: Print "After sorting:"
  // TODO: Affichez chaque tâche de la liste triée
}