Perché i metodi hashCode e l'operatore di confronto == vengono sovrascritti?

La ridefinizione di hashCode e dell'operatore == (per confrontare gli oggetti per valore anziché per riferimento) è necessaria per il corretto funzionamento delle collezioni basate su hash, come HashSet e HashMap.

• Operatore == : Determina quando due oggetti sono considerati uguali. Per impostazione predefinita, confronta i riferimenti degli oggetti. Redifendendolo, implementiamo la logica di confronto per contenuto o attributi dell'oggetto.
• Metodo hashCode : Restituisce un valore intero (codice hash) per l'oggetto. Se due oggetti sono uguali secondo ==, i loro hashCode dovrebbero essere uguali. Il contrario non è vero (due oggetti possono avere lo stesso hashCode ma essere diversi).

La violazione di questo contratto (oggetti uguali con hashCode diversi) porta a un funzionamento errato delle collezioni hash: gli elementi possono essere aggiunti più volte dove si aspetta unicità (HashSet), o non trovati (HashMap).

Esempio:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Verifica che other sia una Person
    if (identical(this, other)) return true;
    if (other.runtimeType != runtimeType) return false;
    // Confronta gli attributi
    return other is Person && name == other.name && age == other.age;
  }

  @override
  int get hashCode => Object.hash(name, age); // Genera hash dagli attributi
}

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

  print(p1 == p2); // true (confronto per valore dopo la ridefinizione)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (ricerca tramite hash e confronto)
}