equals() y hashCode()

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy — lección 42 de 87.

Al comparar objetos en Java, el operador == comprueba si dos referencias apuntan a la misma ubicación de memoria. Para comparar el contenido real de los objetos, es necesario sobrescribir el método equals().

public class Person {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

El método equals() sigue un patrón estándar: primero verifica si es el mismo objeto, luego verifica el tipo y finalmente compara los campos relevantes.

Siempre que sobrescribas equals(), también debes sobrescribir hashCode(). Este es un contrato en Java: los objetos que son iguales deben tener el mismo código hash. Las colecciones basadas en hash como HashMap y HashSet dependen de esta regla para funcionar correctamente.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

El método de utilidad Objects.hash() genera un código hash a partir de los mismos campos utilizados en equals(). Si dos objetos Person tienen el mismo nombre y edad, se considerarán iguales y producirán códigos hash idénticos, asegurando un comportamiento consistente en las colecciones.

Desafío

Fácil

Construyamos un sistema de registro de estudiantes que implemente correctamente la igualdad de objetos. Crearás una clase Student donde dos estudiantes se consideran iguales si tienen el mismo ID de estudiante y nombre, independientemente de si son el mismo objeto en memoria.

Organizarás tu código en dos archivos:

Student.java: Crea una clase que represente a un estudiante con tres campos privados: studentId (String), name (String) y gpa (double). Incluye un constructor para inicializar todos los campos y métodos getter para cada campo.
Sobrescribe el método equals() para que dos objetos Student se consideren iguales cuando tengan el mismo studentId Y el mismo name. Sigue el patrón estándar: verifica si es la misma referencia, verifica si es nulo y el tipo, luego compara los campos relevantes.

Sobrescribe el método hashCode() usando Objects.hash() con los mismos campos utilizados en equals(). Recuerda importar java.util.Objects en la parte superior de tu archivo.
Main.java: Da vida a tu clase Student comparando objetos de estudiante. Recibirás seis entradas que representan a dos estudiantes: el ID, nombre y GPA del primer estudiante, seguidos por el ID, nombre y GPA del segundo estudiante.
Crea ambos objetos Student, luego realiza tres comparaciones e imprime los resultados:
1. Imprime Same reference: seguido de si el primer estudiante es igual a sí mismo (siempre debería ser true)
2. Imprime Content equality: seguido de si el primer estudiante es igual al segundo estudiante (basado en tu implementación de equals)
3. Imprime Hash codes match: seguido de si ambos estudiantes tienen el mismo hash code

Recibirás seis entradas: ID del primer estudiante (String), nombre del primer estudiante (String), GPA del primer estudiante (double), ID del segundo estudiante (String), nombre del segundo estudiante (String) y GPA del segundo estudiante (double).

Observa cómo cuando dos estudiantes tienen IDs y nombres coincidentes, tanto equals() devuelve true Y sus hash codes coinciden; ¡este es el contrato que debes mantener!

Hoja de referencia

El operador == comprueba si dos referencias apuntan a la misma ubicación de memoria, no si los objetos tienen el mismo contenido.

Para comparar el contenido de los objetos, sobrescriba el método equals() siguiendo este patrón:

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;  // Misma referencia
    if (obj == null || getClass() != obj.getClass()) return false;  // Nulo o tipo diferente
    Person person = (Person) obj;  // Conversión al tipo correcto
    return age == person.age && name.equals(person.name);  // Comparar campos
}

Siempre que sobrescriba equals(), también debe sobrescribir hashCode(). Este es un contrato de Java: los objetos iguales deben tener el mismo código hash.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

Use Objects.hash() con los mismos campos utilizados en equals(). Esto garantiza que las colecciones basadas en hash como HashMap y HashSet funcionen correctamente.

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer los datos del primer estudiante
        String id1 = scanner.nextLine();
        String name1 = scanner.nextLine();
        double gpa1 = scanner.nextDouble();
        scanner.nextLine(); // consumir el salto de línea
        
        // Leer los datos del segundo estudiante
        String id2 = scanner.nextLine();
        String name2 = scanner.nextLine();
        double gpa2 = scanner.nextDouble();
        
        // TODO: Crear dos objetos Student usando los datos de entrada
        
        // TODO: Imprimir "Same reference: " seguido de si student1 es igual a sí mismo
        
        // TODO: Imprimir "Content equality: " seguido de si student1 es igual a student2
        
        // TODO: Imprimir "Hash codes match: " seguido de si ambos estudiantes tienen el mismo código hash
    }
}