Anulación del método equals()
=== ==. ================ Este es un método igual a() anulado en String. método
/**
* Compara esta cadena con el objeto especificado. El resultado es {@code
si y sólo si el argumento no es {@code null} y es un objeto {@code
*String} que representa la misma secuencia de caracteres que este objeto * verdadero.
*
* @param anObject
* El objeto para comparar esta {@code String} con
*
* @return {@code true} Si el objeto dado representa un {@code String} equivalente a esta cadena
* Devuelve {@code true}; de lo contrario, devuelve {@code false}
*
* @see #compareTo(String)
* @see #equalsIgnoreCase(String)
*/
público booleano es igual (Objeto unObjeto) {
if (this == unObjeto) {
return true;
}
if (una instancia de Objeto de Cadena) {
Cadena otra Cadena = (Cadena)unObjeto;
int n = recuento;
if (n == anotherString.count) {
char v1[] = valor;
char v2 [] = anotherString.value;
int i = offset;
int j = otraCadena.offset;
while (n-- ! = 0) {
if (v1[i++] != v2[j++])
Devuelve falso;
}
Devuelve verdadero;
}
}
Devuelve falso;
}
========================== ======= ===========
Como dije, el método igual de la clase de objeto compara el código hash, si String no sobrecarga igual
El valor de retorno de s1.equals(s2) debería ser falso, pero de hecho devuelve verdadero. Esto también es lo que dice el libro sobre iguales de String.
Esto es lo que dice el libro. El método igual de String ha sido reescrito
====================== Para explicar el problema. más profundamente, anulemos el método igual de MyValue en su ejemplo, y luego podrá compararlo con su ejemplo actual
public class OperadoresAndExpressions { //Operaciones y expresiones
/**
* @param args
*/
void equalsMethod2(){
String s1=new String("hola ");
String s2=new String("hola");
System.out.println(s1==s2
System.out .println(s1); .equals(s2));
Class MyValue{ // Clase interna, clase definida por el usuario Por lo tanto, el método equals() de la clase MyValue hereda de
int i ;// Clase de objeto, su función sigue siendo comparar dos operandos para ver si son el mismo objeto
// Para explicar más profundamente el uso de la sobrecarga del método igual, sobrecarguémoslo aquí igual.
@Override
público booleano es igual (Objeto o){
if(this == o){
devuelve verdadero;
}
if(o instancia de MyValue){