¿Por qué se sobrescriben los métodos hashCode y el operador de comparación ==?

La sobrescritura de hashCode y del operador == (para comparar objetos por valor en lugar de por referencia) es necesaria para el correcto funcionamiento de colecciones basadas en hash, como HashSet y HashMap.

• Operador ==: Define cuándo dos objetos se consideran iguales. Por defecto, compara las referencias de los objetos. Al sobrescribirlo, implementamos la lógica de comparación por contenido o atributos del objeto.
• Método hashCode: Devuelve un valor entero (código hash) para el objeto. Si dos objetos son iguales según el operador ==, sus hashCode deben ser iguales. Lo contrario no es cierto (dos objetos pueden tener el mismo hashCode pero no ser iguales).

El incumplimiento de este contrato (objetos iguales con diferentes hashCode) conduce a un funcionamiento incorrecto de las colecciones hash: los elementos pueden ser añadidos varias veces donde se espera unicidad (HashSet), o no podrán ser encontrados (HashMap).

Ejemplo:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Verifica que other sea Person
    if (identical(this, other)) return true;
    if (other.runtimeType != runtimeType) return false;
    // Compara atributos
    return other is Person && name == other.name && age == other.age;
  }

  @override
  int get hashCode => Object.hash(name, age); // Genera hash a partir de los atributos
}

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

  print(p1 == p2); // true (comparación por valor tras sobrescribir)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (búsqueda por hash y comparación)
}