Miért írják felül a hashCode metódust és az == összehasonlító operátort?

A hashCode és az == operátor felülírása (az objektumok érték szerinti, nem referencia szerinti összehasonlítása) szükséges a hash-alapú kollekciók, például a HashSet és a HashMap helyes működéséhez.

• Az == operátor: Meghatározza, mikor tekintünk két objektumot egyenlőnek. Alapértelmezés szerint az objektumokra mutató hivatkozásokat hasonlítja össze. Felülírva a tartalom vagy az attribútumok szerinti összehasonlítást valósítjuk meg.
• A hashCode metódus: Egy egész számot (hash-kódot) ad vissza az objektumhoz. Ha két objektum == szerint egyenlő, akkor a hashCode-juk egyenlő kell legyen. Fordítva nem feltétlenül igaz (két objektum ugyanazt a hash-kódot is kaphat, de nem kell, hogy egyenlőek legyenek).

A szerződés megszegése (egyenlő objektumok eltérő hash-kódokkal) hibás működést eredményez a hash-alapú kollekciókban: az elemek többször is hozzáadhatók, ahol egyediség várható (HashSet), vagy nem találhatók meg (HashMap).

Példa:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Ellenőrzi, hogy other Person-e
    if (identical(this, other)) return true;
    if (other.runtimeType != runtimeType) return false;
    // Összehasonlítja az attribútumokat
    return other is Person && name == other.name && age == other.age;
  }

  @override
  int get hashCode => Object.hash(name, age); // Hash generálás attribútumokból
}

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

  print(p1 == p2); // true (érték szerinti összehasonlítás, felülírás után)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (hash és összehasonlítás alapján keresés)
}