Pourquoi les méthodes hashCode et l'opérateur de comparaison == sont-ils redéfinis ?

La redéfinition de hashCode et de l'opérateur == (pour comparer des objets par valeur plutôt que par référence) est nécessaire pour le bon fonctionnement des collections basées sur le hachage, telles que HashSet et HashMap.

• Opérateur == : Détermine quand deux objets sont considérés comme égaux. Par défaut, il compare les références des objets. En le redéfinissant, nous implémentons la logique de comparaison par contenu ou attributs de l'objet.
• Méthode hashCode : Retourne une valeur entière (code de hachage) pour l'objet. Si deux objets sont égaux selon l'opérateur ==, leurs hashCode doivent être identiques. L'inverse n'est pas vrai (deux objets peuvent avoir le même hashCode mais ne pas être égaux).

Le non-respect de ce contrat (objets égaux avec des hashCode différents) entraîne un fonctionnement incorrect des collections hashées : les éléments peuvent être ajoutés plusieurs fois là où l'unicité est attendue (HashSet), ou ne pas être trouvés (HashMap).

Exemple :

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Vérifie que other est une Person
    if (identical(this, other)) return true;
    if (other.runtimeType != runtimeType) return false;
    // Compare les attributs
    return other is Person && name == other.name && age == other.age;
  }

  @override
  int get hashCode => Object.hash(name, age); // Génère un hash à partir des attributs
}

void main() {
  final p1 = Person('Alice', 30);
  final p2 = Person('Alice', 30);
  final p3 = Person('Bob', 25);

  print(p1 == p2); // true (comparaison par valeur après redéfinition)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (recherche par hash et comparaison)
}