¿Por qué tenemos que anular el método equals () en Java?

Tengo cierta confusión sobre la razón por la que .equals método .equals .

Por ejemplo:

 Test test1 = new Test(3); Test test2 = new Test(3); //The if comparison does the same thing that the overridden `.equals()` method does. if(test1.equals(test2)){ System.out.println("test1 and test2 are true in .equals()"); } // Override .equals method. public boolean equals(Object object) { if(object instanceof Test && ((Test)object).getValue() == this.t) { return true; } else { return false; } } 

No entiendo por qué tenemos que anular el método .equals() .

Del artículo Override equals y hashCode en Java :

La implementación predeterminada de la clase equals () proporcionada por java.lang.Object compara la ubicación de la memoria y solo devuelve verdadero si dos variables de referencia apuntan a la misma ubicación de memoria, es decir, esencialmente son el mismo objeto.

Java recomienda reemplazar los métodos equals y hashCode si la igualdad se va a definir de forma lógica o mediante alguna lógica comercial : ejemplo:

muchas clases en la biblioteca estándar de Java lo anulan, p. ej. String anula equals, cuya implementación del método equals () devuelve true si el contenido de dos objetos String es exactamente el mismo

La clase contenedora de enteros reemplaza a los iguales para realizar una comparación numérica, etc.

Esto debería ser suficiente para responder a su pregunta: http://docs.oracle.com/javase/tutorial/java/IandI/objectclass.html

El método equals() compara dos objetos para igualdad y devuelve true si son iguales. El método equals() proporcionado en la clase Object usa el operador de identidad ( == ) para determinar si dos objetos son iguales. Para tipos de datos primitivos, esto da el resultado correcto. Para los objetos, sin embargo, no es así. El método equals() proporcionado por Object comprueba si las referencias de los objetos son iguales, es decir, si los objetos comparados son exactamente el mismo objeto.

Para probar si dos objetos son iguales en el sentido de equivalencia (que contiene la misma información), debe anular el método equals() .

(Cita parcial: haga clic para leer ejemplos).

.equals () no realiza una comparación inteligente para la mayoría de las clases a menos que la clase lo anule. Si no está definido para una clase (usuario), se comporta igual que ==.

Referencia: http://www.leepoint.net/notes-java/data/expressions/22compareobjects.html http://www.leepoint.net/data/expressions/22compareobjects.html

El comportamiento predeterminado para java.lang.Object es comparar referencias, pero eso no es apropiado para cada tipo de objeto. Hay cosas llamadas objetos de valor (como BigDecimal o String), donde los objetos con el mismo valor se consideran intercambiables, por lo que el comportamiento predeterminado de iguales no es deseable. Esos tipos de objetos tienen que implementar equals y hashcode en función del valor que asume el objeto.

Para responder a su pregunta, en primer lugar recomendaría encarecidamente consultar la Documentación .

Sin anular el método equals (), actuará como “==”. Cuando utiliza el operador “==” en objetos, simplemente comprueba si esos punteros se refieren al mismo objeto. No si sus miembros contienen el mismo valor.

Anulamos para mantener nuestro código limpio, y abstraemos la lógica de comparación de la statement If, en el objeto. Esto se considera una buena práctica y aprovecha Java enfoque fuertemente orientado a objetos.

Déjame darte un ejemplo que encuentro muy útil.

Puede pensar en la referencia como el número de página de un libro. Supongamos que ahora tiene dos páginas a y b como a continuación.

BookPage a = getSecondPage ();

BookPage b = getThirdPage ();

En este caso, a == b te dará falso. ¿Pero por qué? La razón es que lo que == está haciendo es como comparar el número de página. Por lo tanto, incluso si el contenido de estas dos páginas es exactamente el mismo, igual obtendrá falso.

Pero, ¿qué hacemos si queremos comparar el contenido?

La respuesta es escribir su propio método de igualdad y especificar lo que realmente quiere comparar.

Por defecto, .equals () usa == función de identidad para comparar, lo que obviamente no funciona, ya que las instancias test1 y test2 no son lo mismo. == solo funciona con tipos de datos primitivos como int o string. Por lo tanto, debe anularlo para que funcione al comparar todas las variables miembro de la clase Prueba

El método Object.equals () comprueba solo la referencia del objeto, no el tipo de datos primitivo o el valor del objeto (objeto de la clase Wrapper de datos primitivos, tipo de datos simple primitivo (byte, corto, int, largo, etc.)). De modo que debemos anular el método equals () cuando comparamos el objeto en función del tipo de datos primitivo.