Por que os métodos hashCode e o operador de comparação == são sobrescritos?

A redefinição de hashCode e do operador == (para comparar objetos por valor, não por referência) é necessária para o funcionamento correto de coleções baseadas em hash, como HashSet e HashMap.

• Operador == : Define quando dois objetos são considerados iguais. Por padrão, compara referências de objetos. Ao redefini-lo, implementamos a lógica de comparação por conteúdo ou atributos do objeto.
• Método hashCode : Retorna um valor inteiro (código hash) para o objeto. Se dois objetos forem iguais segundo o operador ==, seus hashCode devem ser iguais. O inverso não é verdadeiro (dois objetos podem ter o mesmo hashCode, mas não serem iguais).

O não cumprimento deste contrato (objetos iguais com hashCode diferentes) leva a um funcionamento incorreto de coleções hash: elementos podem ser adicionados várias vezes onde se espera unicidade (HashSet), ou não podem ser encontrados (HashMap).

Exemplo:

class Person {
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  bool operator ==(Object other) {
    // Verifica se other é uma 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); // Gera hash a partir dos atributos
}

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

  print(p1 == p2); // true (comparação por valor após redefinição)
  print(p1 == p3); // false

  final peopleSet = {p1};
  print(peopleSet.contains(p2)); // true (busca por hash e comparação)
}