Waarom worden de methoden hashCode en de vergelijking operator == overschreven?

Het overschrijven van hashCode en de operator == (om objecten op waarde te vergelijken in plaats van op referentie) is nodig voor het correct functioneren van op hash gebaseerde collecties zoals HashSet en HashMap.

• Operator == : Bepaalt wanneer twee objecten als gelijk worden beschouwd. Standaard vergelijkt het de referenties van de objecten. Door het te overschrijven, implementeren we de logica voor vergelijking op basis van inhoud of attributen van het object.
• Methode hashCode : Geeft een gehele waarde (hash-code) terug voor het object. Als twee objecten gelijk zijn volgens ==, moeten hun hashCode gelijk zijn. Het omgekeerde is niet waar (twee objecten kunnen dezelfde hashCode hebben maar niet gelijk zijn).

Het niet naleven van dit contract (gelijke objecten met verschillende hashCode) leidt tot incorrect gedrag van hash-gebaseerde collecties: elementen kunnen meerdere keren worden toegevoegd waar uniciteit wordt verwacht (HashSet), of niet worden gevonden (HashMap).

Voorbeeld:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Controleer of other een Person is
    if (identical(this, other)) return true;
    if (other.runtimeType != runtimeType) return false;
    // Vergelijk attributen
    return other is Person && name == other.name && age == other.age;
  }

  @override
  int get hashCode => Object.hash(name, age); // Hash genereren uit attributen
}

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

  print(p1 == p2); // true (vergelijking op waarde na overschrijven)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (zoeken op hash en vergelijking)
}