¿Qué hace igual (Object obj)?

Question

A menudo he encontrado un método igual en diferentes lugares. ¿Qué es lo que hace? ¿Es importante que tengamos esto en todas las clases?

public boolean equals(Object obj) 
    { 
    if (obj == this) 
    { 
     return true; 
    } 
    if (obj == null) 
    { 
     return false; 
    } 
    if (obj instanceof Contact) 
    { 
     Contact other = (Contact)obj; 
     return other.getFirstName().equals(getFirstName()) && 
       other.getLastName().equals(getLastName()) && 
       other.getHomePhone().equals(getHomePhone()) && 
       other.getCellPhone().equals(getCellPhone()); 

    } 
    else 
    { 
     return false; 
    } 
} 

Answer 1

Se redefine la "igualdad" de los objetos.

Por defecto (definido en java.lang.Object), un objeto es igual a otro objeto sólo si es la misma instancia. Pero puede proporcionar lógica de igualdad personalizada cuando la anula.

Por ejemplo, java.lang.String define la igualdad comparando la matriz de caracteres internos. Es por eso que:

String a = new String("a"); //but don't use that in programs, use simply: = "a" 
String b = new String("a"); 
System.out.println(a == b); // false 
System.out.println(a.equals(b)); // true 

Aunque no necesite probar la igualdad de esa manera, las clases que usa lo hacen. Por ejemplo, las implementaciones de List.contains(..) y List.indexOf(..) usan .equals(..).

Compruebe the javadoc para obtener el contrato exacto requerido por el método equals(..).

En muchos casos al anular equals(..) también debe sobrescribir hashCode() (utilizando los mismos campos). Eso también está especificado en el javadoc.

Answer 2

Le permite volver a definir qué objetos son iguales y cuáles no, por ejemplo, puede definir que dos Person objetos como iguales si la Person.ID es el mismo o si el Weight es igual dependiendo de la lógica de la aplicación.

ver esto: Overriding the java equals() method quirk

Answer 3

diferentes clases tienen diferentes criterios para lo que hace que los objetos 2 "iguales". Normalmente, es igual a() devuelve verdadero si se trata del mismo objeto:

Object a = new Object(); 
Object b = new Object(); 
return(a.equals(b)); 

Esto devolverá falso, apesar de que ambos son clases "objeto", no son la misma instancia. a.equals(a) devolverá verdadero.

Sin embargo, en casos como una cadena, puede tener 2 casos diferentes, pero la igualdad cadena se basa en los caracteres literales que componen esos Cuerdas:

String a = new String("example"); 
String b = new String("example"); 
String c = new String("another"); 
a.equals(b); 
a.equals(c); 

Estas son todas diferentes instancias de la cadena, pero la primeros iguales se devuelven verdadero porque ambos son "ejemplo", pero el segundo no debido "ejemplo" no es "otro".

No tendrá que anular equals() para cada clase, solo cuando haya un caso especial para igualdad, como una clase que contenga 3 cadenas, pero solo la primera cadena se usa para determinar la igualdad. En el ejemplo que usted envió, no podría haber sido otro campo, description que puede ser diferente para 2 "Contactos" diferentes, pero 2 "Contactos" se consideran iguales si los 4 criterios de coincidencia (nombre/apellido, y el hogar de teléfono/celular números), mientras que la descripción que coincide o no coincide no funciona si 2 contactos son iguales.

Answer 4

El método equals se utiliza cuando se quiere saber si dos objetos son equivalentes por cualquier definición que los objetos encuentren adecuados.Por ejemplo, para los objetos String, la equivalencia se trata de si los dos objetos representan la misma cadena de caracteres. Por lo tanto, las clases suelen proporcionar su propia implementación de equals que funciona de la manera natural para esa clase.

El método equals es diferente de == en que este último prueba la identidad del objeto, es decir, si los objetos son iguales (lo que no es necesariamente lo mismo que el equivalente).

Answer 5

Aparte de todo lo determinado por Bozho, hay algunas cosas adicionales a tener en cuenta si primordial es igual a:

• algo.equals(null) siempre debe devolver false - es decir, nulo no es igual a cualquier otra cosa. Este requisito se atiende en el segundo si de su código.

• si bien es cierto que algo == algo más, entonces también algo .equals(algo más) también debe ser verdad. (es decir, los objetos idénticos deben ser iguales) El primer si de su código se ocupa de esto.

• .equals debería ser symetric para objetos que no son nulos, es decir a.equals(b) debería ser el mismo que b.equals(a). A veces, este requisito se rompe si está subclasando y anulando iguales en la clase padre y en la subclase. A menudo es igual a contiene código como if (!getClass().equals(other.getClass())) return false; que al menos se asegura de que un tipo de objeto diferente no sea igual entre sí.

• Si reemplaza equals También debe anular hashCode de tal manera que la expresión siguiente es cierto: if (a.equals(b)) assert a.hashCode() == b.hashCode(). Es decir. el código hash de dos objetos que son iguales entre sí debe ser el mismo. Tenga en cuenta que lo contrario no es cierto: dos objetos que tienen el mismo código hash pueden o no ser iguales entre sí. Usualmente, este requisito se soluciona derivando el hashCode de las mismas propiedades que se usan para determinar la igualdad de un objeto.

En su caso, el método hashCode podría ser:

public int hashCode() { 
    return getFirstName().hashCode() + 
    getLastName().hashCode() + 
    getPhoneHome().hashCode() + 
    getCellPhone().hashCode(); 
} 

• Si implementa Comparable que compara dos objetos si son más pequeños, más grandes o iguales entre sí, a.compareTo(b) == 0 debería haber verdadero si y sólo si a.equalTo(b) == true

En muchos entornos de desarrollo (por ejemplo, Eclipse, IntelliJ IDEA, NetBeans) hay características que g enerate equals y hashCode para ti, evitándote de este modo el trabajo tedioso y propenso a errores.