Conceptos básicos de JAVA: la relación entre hashCode y iguales

es igual

equals() se deriva de java.lang.Object. Este método se utiliza para verificar simplemente la igualdad de dos objetos. La implementación predeterminada definida en la clase Objeto solo verifica las referencias de dos objetos para verificar su igualdad. Al anular este método, puede personalizar nuevas reglas para verificar la igualdad de objetos. Si usa ORM para procesar algunos objetos, asegúrese de usar captadores y definidores en objetos hashCode() y iguales() en lugar de hacer referencia directa a las variables miembro.

//equals源码
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

código hash

hashCode() se deriva de java.lang.Object. Este método se utiliza para obtener el número entero único (código hash) de un objeto determinado. Este número entero se utiliza para determinar la ubicación del depósito cuando el objeto debe almacenarse en una estructura de datos como una tabla hash. De forma predeterminada, el método hashCode() de un objeto devuelve una representación entera de la dirección de memoria donde se encuentra el objeto. hashCode() es utilizado por HashTable, HashMap y HashSet. De forma predeterminada, el método hashCode() de la clase Object devuelve el número de la dirección de memoria donde está almacenado este objeto.

    //hashCode源码
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

La relación entre hashcode y iguales

Eche un vistazo a los siguientes dos ejemplos.

Ejemplo uno:

public static void main(String[] args) {
    String a = new String("123");
    String b = new String("123");
    System.out.println(a.hashCode()); //48690
    System.out.println(b.hashCode()); //48690
    System.out.println(a.equals(b));  //true
    System.out.println(a == b);  //false
}

Ejemplo dos:

En este ejemplo, se reescribe hashCode.

    public static void main(String[] args) {
        class Object1{
            private final int hashCode = 21;
            public int hashCode(){
                return hashCode;
            }
        }
        class Object2{
            private final int hashCode = 21;
            public int hashCode(){
                return hashCode;
            }
        }
        Object1 object1 = new Object1();
        Object2 object2 = new Object2();
        Object1 object3 = new Object1();
        
        System.out.println(object1.hashCode()); //21
        System.out.println(object2.hashCode()); //21
        System.out.println(object3.hashCode()); //21
        System.out.println(object1.hashCode() == object2.hashCode()); //true
        System.out.println(object1.equals(object3)); //false
    }

A través de los dos ejemplos anteriores, se pueden resumir los siguientes cuatro puntos:

1. igual () se utiliza para determinar si dos objetos son iguales

2. La función de hashCode() es obtener el código hash del objeto; el código hash es generalmente un número entero y se utiliza para determinar la posición del índice del objeto en la tabla hash. Por ejemplo, HashMap se implementa esencialmente a través de una matriz. Cuando queremos obtener un determinado "valor", en realidad queremos obtener el elemento en una determinada posición en la matriz. La posición del array se obtiene a través de la "clave", además se calcula a través del código hash correspondiente a la "clave"

3. Si dos objetos necesitan ser iguales (iguales), entonces deben tener el mismo código hash (hashCode)

4. Pero si dos objetos tienen el mismo código hash, no son necesariamente iguales (el método igual se anula, entonces el método hashCode también debe anularse. Si no se anula hashCode, incluso si los dos objetos apuntan a los mismos datos, entonces no importa lo que no será igual)

La siguiente es la explicación oficial de equals() y hashCode():

Si dos objetos son iguales según el método igual (Objeto), entonces llamar al método hashCode en cada uno de los dos objetos debe producir el mismo resultado entero.
No es necesario que si dos objetos no son iguales según el método igual (java.lang.Object), llamar al método hashCode en cada uno de los dos objetos deba producir resultados enteros distintos. Sin embargo, el programador debe tener en cuenta que producir resultados enteros distintos para objetos desiguales puede mejorar el rendimiento de las tablas hash.