Domina el uso de iguales a través de los siguientes ejemplos.
paquete cn.galc.test;public class TestEquals { public static void main(String[] args) { /** * Aquí, el método de construcción Cat() se utiliza para crear dos nuevos gatos en la memoria del montón * Los dos gatos. son El color, el peso y la altura son todos iguales, * pero c1 y c2 nunca serán iguales. Esto se debe a que c1 y c2 son objetos de referencia de los dos gatos en la memoria del montón. Contiene las direcciones donde se pueden encontrar los dos gatos, pero como los dos gatos están almacenados en dos espacios diferentes en la memoria del montón, * c1 y c2 contienen direcciones diferentes, por lo que c1 y c2 nunca serán iguales. */ Cat c1 = new Cat(1, 1, 1); Cat c2 = new Cat(1, 1, 1 System.out.println("El resultado de c1==c2 es: "+(c1==); c2 ));//false System.out.println("El resultado de c1.equals(c2) es: "+c1.equals(c2));//false }}class Cat { int color, peso, altura; gato público (int color, int peso, int altura) { this.color = color; this.weight = peso this.height = altura }}Dibuje un diagrama de análisis de memoria para analizar los resultados de la comparación entre c1 y c2.
programa:
Cat c1 = nuevo Cat(1,1,1);Cat c2 = nuevo Cat(1,1,1);
Después de la ejecución, el diseño en la memoria se muestra a continuación:
c1 apunta a un objeto y c2 también apunta a un objeto. C1 y c2 contienen las direcciones almacenadas en la memoria del montón de estos dos objetos Cat. Dado que los dos objetos Cat están ubicados en diferentes espacios de almacenamiento, c1 y c2 contienen las direcciones de. Definitivamente no son iguales, por lo que los dos objetos de referencia c1 y c2 definitivamente no son iguales. Por lo tanto, si ejecuta: "System.out.println(c1==c2);" el resultado impreso definitivamente será falso. Entonces creas dos objetos con new. No te preocupes, las referencias de los dos objetos nunca serán las mismas. Si son iguales, uno de ellos se sobrescribirá. Si c1 es igual a c2 compara el contenido de las dos referencias c1 y c2, porque las referencias de los dos objetos producidos por new nunca son las mismas, por lo que los contenidos de las dos referencias c1 y c2 tampoco son nunca los mismos. c1 nunca puede ser igual a c2. Por lo tanto, comparar las referencias de dos objetos nunca puede hacer que los dos objetos sean iguales o idénticos.
Para determinar si dos objetos son iguales, no puede comparar si las referencias de los dos objetos son iguales. Nunca obtendrá un resultado igual porque las referencias de los dos objetos nunca serán iguales, por lo que el método de comparación correcto es compararlos directamente. dos objetos y compare si la esencia de los dos objetos es la misma, es decir, si el contenido de los dos objetos es el mismo. Determine si los dos objetos son iguales comparando si los valores de los atributos de los dos objetos. son los mismos.
La clase Object proporciona un método igual () para comparar si el contenido de dos objetos es el mismo, por lo que podemos usar este método para comparar si los dos objetos son lógicamente "iguales". Por ejemplo: c1.equals(c2); Aquí está la llamada al método igual () heredado de la clase Objeto. Consultando la documentación de la API, la definición del método igual en la clase Objeto es la siguiente:
público booleano es igual (Objeto obj)
La implementación predeterminada del método Equals() proporcionado en la clase Object es comparar la referencia del objeto actual y la referencia que desea comparar para ver si apuntan al mismo objeto, que es lo mismo que "c1==c2 ". , "c1.equals(c2)" y "c1==c2" son completamente equivalentes. Por lo tanto, el uso directo del método igual () heredado no puede comparar directamente si el contenido de dos objetos es el mismo. Por esta razón, debemos anular el método igual () y cambiar la implementación predeterminada de este método.
A continuación, reescribe el método equals() heredado en la clase Cat:
class Cat { int color, peso, altura; public Cat(int color, int peso, int altura) { this.color = color; this.weight = this.height = altura; El método equals() heredado de la clase Object cambia la implementación predeterminada de este método. * Utilice nuestra propia implementación definida para determinar si dos objetos son lógicamente iguales. * Aquí definimos que si el color, peso y altura de dos gatos son iguales, * entonces pensamos que los dos gatos son lógicamente idénticos, es decir, los dos gatos son "iguales". */ public boolean equals(Object obj){ if (obj==null){ return false } else{ /** * instancia de es un operador de objeto. * El operador de objeto se utiliza para determinar si un objeto pertenece a una instancia de una clase o subclase específica. * El operador de objeto es una palabra combinada instancia de. * Este operador es un operador binario. La expresión de la izquierda es un objeto y la expresión de la derecha es una clase. * Si el objeto de la izquierda es un objeto creado por la clase de la derecha, el resultado de la operación es. verdadero, en caso contrario es falso. */ if (obj instancia de Cat){ Cat c = (Cat)obj; if (c.color==this.color && c.weight==this.weight && c.height==this.height){ return true; } } } devuelve falso; }} En este momento, ejecute el comando de impresión en el método principal:
public static void main(String[] args) { /** * Aquí, el método de construcción Cat() se utiliza para crear dos nuevos gatos en la memoria del montón * El color, el peso y la altura de estos dos gatos son los mismos. * Pero c1 y c2 nunca serán iguales. Esto se debe a que c1 y c2 son objetos de referencia de los dos gatos en la memoria del montón. * contiene las direcciones donde se pueden encontrar los dos gatos, pero porque los dos gatos están almacenados en el. memoria de montón En dos espacios diferentes, * Entonces c1 y c2 tienen direcciones diferentes, por lo que c1 y c2 nunca serán iguales. */ Cat c1 = new Cat(1, 1, 1); Cat c2 = new Cat(1, 1, 1 System.out.println("El resultado de c1==c2 es: "+(c1==); c2 ));//false System.out.println("El resultado de c1.equals(c2) es: "+c1.equals(c2));//true }El resultado obtenido esta vez es diferente del resultado obtenido la última vez sin anular el método equals():
"System.out.println(c1 == c2);" El resultado impreso sigue siendo falso, porque los contenidos de las referencias de los dos objetos, por supuesto, no son iguales y nunca serán iguales. son iguales, por lo que el resultado impreso debe ser falso.
"System.out.println(c1.equals(c2));" El resultado impreso es verdadero, porque reescribimos el método equals() en la clase Cat y cambiamos la implementación predeterminada de este método. el método Cambiar a solo Si estos dos objetos realmente existen y ambos son gatos, y su color, altura y peso son iguales, entonces los dos gatos son lógicamente idénticos y exactamente iguales, es decir, estos dos gatos son "iguales". Entonces el resultado impreso aquí es verdadero.
Entonces, ¿cómo comparar la igualdad de dos objetos de cadena?
Mira el siguiente ejemplo:
clase pública TestEquals { public static void main(String args[]){ String s1 = new String("hola"); new String("hola"); : "+(s1 == s2));//falso System.out.println("El resultado de s1.equals(s2) es: "+s1.equals(s2));//true }}Esta vez se compara la igualdad de los dos objetos de cadena:
System.out.println(s1 == s2);
El resultado impreso sigue siendo falso, porque aquí se comparan las referencias de los dos objetos de cadena s1 y s2. Las referencias de los dos objetos nunca serán iguales, por lo que el resultado impreso es falso.
System.out.println(s1.equals(s2));
El resultado impreso es verdadero, porque la herencia de la clase Object se reescribe en la clase String (todas las clases se heredan de la clase Object y, por supuesto, la clase String no es una excepción. Si heredas de la clase principal, tienes todo de la clase principal. Atributos y métodos, por lo que la clase Sting también tiene el método igual (), y el método igual () heredado también se ha reescrito), cambiando la implementación predeterminada de este método.
En la clase String, la implementación del método equals() se anula de esta manera: compara el objeto de cadena actual con el objeto de cadena especificado. El objeto de cadena especificado no puede estar vacío y la secuencia de caracteres de este objeto es la misma que la de la cadena actual. Las secuencias de cadenas de los objetos son las mismas. Si se cumplen estas condiciones, entonces los dos objetos de cadena son iguales.
Por lo tanto, aquí s2 cumple la condición, por lo que el resultado impreso es verdadero.
En el futuro, cuando compare la igualdad de dos objetos en una determinada clase, primero vaya a la documentación de la API para averiguar si esta clase ha anulado el método igual () heredado de la clase Objeto. Si se anula el método igual (), entonces se llama al método igual () anulado al comparar si dos objetos son iguales. Si no se anula, entonces se llama directamente al método heredado de la clase Objeto y. utiliza la implementación predeterminada del método equals() para comparar si dos objetos son iguales. Por lo tanto, cada clase puede anular el método igual () heredado de la clase Objeto según sea necesario.
Para encontrar una determinada clase en el documento API, si una clase se puede usar directamente sin introducir un paquete, entonces esta clase debe estar en el paquete java.lang. Por ejemplo, la clase String aquí se puede usar directamente, por lo que la clase String. debe estar en el paquete java.lang. Cuando utilice una determinada clase, verifique qué paquete importa la clase y luego vaya al paquete para buscar la clase. Las clases que no necesitan importar paquetes deben ubicarse en java.lang. Simplemente vaya directamente a java.lang para encontrarla. .
Generalmente, cuando diseñamos una clase, necesitamos anular el método igual de la clase principal. Al reescribir este método, debemos diseñarlo de acuerdo con las siguientes reglas:
1. Reflexividad: para cualquier valor de referencia X, el valor de retorno de x.equals(x) debe ser verdadero.
2. Simetría: para cualquier valor de referencia x, y, si y solo si el valor de retorno de y.equals(x) es verdadero, el valor de retorno de x.equals(y) debe ser verdadero;
3. Transitividad: si x.equals(y)=true, y.equals(z)=true, entonces x.equals(z)=true
4. Consistencia: Si los objetos que participan en la comparación no cambian, el resultado de la comparación de objetos tampoco debería cambiar.
5. No capacidad de nulidad: para cualquier valor de referencia no nulo X, el valor de retorno de x.equals(null) debe ser falso
Por ejemplo:
gente de clase pública {nombre de cadena privada; nombre de cadena privada; nombre de int privado; nombre de cadena pública () {nombre de retorno} nombre de pila público (nombre de cadena) {nombre de primer nombre = nombre de pila público) {nombre de cadena de retorno; } public void setLastName(String lastName) { this.lastName = lastName } public int getAge() { return edad } public void setAge(int edad) { this.age = edad; } @Override public boolean es igual (Objeto obj) { if (this == obj) devuelve verdadero; si (obj == nulo) devuelve falso si (getClass()!= obj.getClass()) devuelve falso; personas otras = (personas) obj; si (edad! = otra.edad) devuelve falso; si (primer nombre == nulo) {si (otro.primer nombre! = nulo) devuelve falso; (!firstName.equals(other.firstName)) devuelve falso si (!lastName == null) { if (other.lastName!= null) devuelve false } else if (!lastName.equals(other.lastName)) devuelve false; ; devolver verdadero; }}
En este ejemplo, estipulamos que una persona es la misma si su apellido, nombre y edad son los mismos. Por supuesto, también puede agregar otros atributos. Por ejemplo, el número de identificación debe ser el mismo para ser juzgado como la misma persona. Luego puede agregar el juicio del número de identificación en el método igual.
Resumen: Para comparar si dos objetos son iguales, utilizamos el método igual () Las condiciones para juzgar si dos objetos son iguales las definimos después de reescribir la implementación del método igual (), de modo que el método igual () pueda. Se puede usar de manera más flexible. Compare dos objetos de la misma clase en diferentes clases para ver si son iguales.