Maîtrisez l'utilisation des égaux à travers les exemples suivants
package cn.galc.test;public class TestEquals { public static void main(String[] args) { /** * Ici, la méthode de construction Cat() est utilisée pour créer deux nouveaux chats dans la mémoire du tas. * Les deux chats. sont La couleur, le poids et la taille sont tous identiques, * mais c1 et c2 ne seront jamais égaux, car c1 et c2 sont des objets de référence des deux chats dans la mémoire du tas, *. Il contient les adresses où les deux chats peuvent être trouvés, mais comme les deux chats sont stockés dans deux espaces différents de la mémoire tas, * c1 et c2 contiennent des adresses différentes, donc c1 et c2 ne seront jamais égaux. */ Cat c1 = new Cat(1, 1, 1); Cat c2 = new Cat(1, 1, 1); System.out.println("Le résultat de c1==c2 est : "+(c1== c2 ));//false System.out.println("Le résultat de c1.equals(c2) est : "+c1.equals(c2));//false }}class Cat { int color, poids, taille ; public Cat(int couleur, int poids, int hauteur) { this.color = couleur; this.weight = poids ; this.height = hauteur }}Dessiner un diagramme d'analyse de mémoire pour analyser les résultats de la comparaison entre c1 et c2
programme:
Cat c1 = nouveau Cat(1,1,1);Cat c2 = nouveau Cat(1,1,1);
Après exécution, la disposition dans la mémoire est la suivante :
c1 pointe vers un objet, et c2 pointe également vers un objet. C1 et c2 contiennent les adresses stockées dans la mémoire tas de ces deux objets Cat étant donné que les deux objets Cat sont situés dans des espaces de stockage différents, c1 et c2 contiennent les adresses de. ne sont définitivement pas égaux, donc les deux objets de référence c1 et c2 ne sont définitivement pas égaux. Par conséquent, si vous exécutez : "System.out.println(c1==c2);" le résultat imprimé sera définitivement faux. Vous créez donc deux objets avec new. Ne vous inquiétez pas, les références des deux objets ne seront jamais identiques, l'une d'entre elles sera écrasée. Que c1 soit égal à c2 compare le contenu contenu dans les deux références c1 et c2, car les références des deux objets produits par new ne sont jamais les mêmes, donc le contenu des deux références c1 et c2 n'est jamais non plus le même. c1 ne peut jamais être égal à c2. Par conséquent, comparer les références de deux objets ne peut jamais rendre les deux objets égaux ou identiques.
Pour déterminer si deux objets sont égaux, vous ne pouvez pas comparer si les références des deux objets sont égales. Vous n'obtiendrez jamais un résultat égal car les références des deux objets ne seront jamais égales, la méthode de comparaison correcte consiste donc à les comparer directement. deux objets et comparez si l'essence des deux objets est la même, c'est-à-dire si le contenu des deux objets est le même. Déterminez si les deux objets sont égaux en comparant si les valeurs d'attribut des deux objets. sont les mêmes.
La classe Object fournit une méthode equals() pour comparer si le contenu de deux objets est identique, nous pouvons donc utiliser cette méthode pour comparer si les deux objets sont logiquement « égaux ». Par exemple : c1.equals(c2); Voici l'appel à la méthode equals() héritée de la classe Object. En consultant la documentation de l'API, la définition de la méthode equals dans la classe Object est la suivante :
public booléen égal (Objet obj)
L'implémentation par défaut de la méthode Equals() fournie dans la classe Object consiste à comparer la référence de l'objet actuel et la référence que vous souhaitez comparer pour voir si elles pointent vers le même objet, ce qui est identique à "c1==c2 ". , "c1.equals(c2)" et "c1==c2" sont complètement équivalents. Par conséquent, l'utilisation directe de la méthode equals() héritée ne peut pas comparer directement si le contenu de deux objets est identique. Pour cette raison, nous devons remplacer la méthode equals() et modifier l'implémentation par défaut de cette méthode.
Ensuite, réécrivez la méthode equals() héritée dans la classe Cat :
class Cat { int couleur, poids, hauteur; public Cat(int couleur, int poids, int hauteur) { this.color = color; this.weight = poids this.height = hauteur } /** * Ceci est une réécriture de l'égalité; La méthode equals() héritée de la classe Object modifie l'implémentation par défaut de cette méthode. * Utilisez notre propre implémentation définie pour déterminer si deux objets sont logiquement égaux. * Ici, nous définissons que si la couleur, le poids et la taille de deux chats sont identiques, * alors nous pensons que les deux chats sont logiquement identiques, c'est-à-dire que les deux chats sont "égaux". */ public boolean equals(Object obj){ if (obj==null){ return false } else{ /** * instanceof est un opérateur d'objet. * L'opérateur d'objet est utilisé pour déterminer si un objet appartient à une instance d'une classe spécifiée ou d'une sous-classe spécifiée. * L'opérateur d'objet est une instance de mot combinée. * Cet opérateur est un opérateur binaire. L'expression de gauche est un objet et l'expression de droite est une classe. * Si l'objet de gauche est un objet créé par la classe de droite, le résultat de l'opération est. vrai, sinon c'est faux. */ if (obj instanceof Cat){ Cat c = (Cat)obj; if (c.color==this.color && c.weight==this.weight && c.height==this.height){ return true; } } } renvoie faux ; }} À ce stade, exécutez la commande d'impression dans la méthode principale :
public static void main(String[] args) { /** * Ici, la méthode de construction Cat() est utilisée pour créer deux nouveaux chats dans la mémoire du tas * La couleur, le poids et la taille de ces deux chats sont les mêmes. . * Mais c1 et c2 ne seront jamais égaux, car c1 et c2 sont des objets de référence des deux chats dans la mémoire tas. * Contient les adresses où les deux chats peuvent être trouvés, mais parce que les deux chats sont stockés dans le tas. tas de mémoire Dans deux espaces différents, * Donc c1 et c2 détiennent des adresses différentes, donc c1 et c2 ne seront jamais égaux. */ Cat c1 = new Cat(1, 1, 1); Cat c2 = new Cat(1, 1, 1); System.out.println("Le résultat de c1==c2 est : "+(c1== c2 ));//false System.out.println("Le résultat de c1.equals(c2) est : "+c1.equals(c2));//true }Le résultat obtenu cette fois est différent du résultat obtenu la dernière fois sans surcharger la méthode equals() :
"System.out.println(c1 == c2);" Le résultat imprimé est toujours faux, car les contenus des références des deux objets sont comparés. Le contenu des deux références n'est bien sûr pas égal, et ne le sera jamais. sont égaux, le résultat imprimé doit donc être faux.
"System.out.println(c1.equals(c2));" Le résultat imprimé est vrai, car nous avons réécrit la méthode equals() dans la classe Cat et modifié l'implémentation par défaut de cette méthode. la méthode Changer en seulement Si ces deux objets existent réellement et sont tous deux des chats, et que leur couleur, leur taille et leur poids sont les mêmes, alors les deux chats sont logiquement identiques et exactement deux chats, c'est-à-dire que ces deux chats sont « égaux ». Le résultat imprimé ici est donc vrai.
Alors, comment comparer deux objets chaîne pour vérifier leur égalité ?
Regardez l'exemple suivant :
public class TestEquals { public static void main(String args[]){ String s1 = new String("hello"); String s2 = new String("hello"); System.out.println("s1 == s2 result Is : "+(s1 == s2));//faux System.out.println("Le résultat de s1.equals(s2) est : "+s1.equals(s2));//true }}Cette fois, les deux objets chaîne sont comparés pour vérifier leur égalité :
System.out.println(s1 == s2);
Le résultat imprimé est toujours faux, car les références des deux objets chaîne s1 et s2 sont comparées ici. Les références des deux objets ne seront jamais égales, donc le résultat imprimé est faux.
System.out.println(s1.equals(s2));
Le résultat imprimé est vrai, car l'héritage de la classe Object est réécrit dans la classe String (toutes les classes sont héritées de la classe Object, et la classe String ne fait bien sûr pas exception. Si vous héritez de la classe parent, vous avez tout de la classe parent. Attributs et méthodes, donc la classe Sting a également la méthode equals(), et la méthode equals() héritée a également été réécrite), modifiant l'implémentation par défaut de cette méthode.
Dans la classe String, l'implémentation de la méthode equals() est remplacée comme ceci : comparez l'objet chaîne actuel avec l'objet chaîne spécifié. L'objet chaîne spécifié ne peut pas être vide et la séquence de caractères de cet objet est la même que celle de la chaîne actuelle. . Les séquences de chaînes des objets sont les mêmes. Si ces conditions sont remplies, alors les deux objets chaîne sont égaux.
Par conséquent, s2 remplit ici la condition, donc le résultat imprimé est vrai.
À l'avenir, lorsque vous comparerez l'égalité de deux objets dans une certaine classe, accédez d'abord à la documentation de l'API pour savoir si cette classe a remplacé la méthode equals() héritée de la classe Object. Si la méthode Equals() est remplacée, alors la méthode Equals() substituée est appelée lors de la comparaison si deux objets sont égaux. Si elle n'est pas remplacée, alors celle héritée de la classe Object est appelée directement. utilise l'implémentation par défaut de la méthode equals() pour comparer si deux objets sont égaux. Par conséquent, chaque classe peut remplacer la méthode equals() héritée de la classe Object selon ses besoins.
Pour trouver une certaine classe dans le document API, si une classe peut être utilisée directement sans introduire de package, alors cette classe doit être dans le package java.lang. Par exemple, la classe String ici peut être utilisée directement, donc la classe String. doit être C'est dans le package java.lang. Lorsque vous utilisez une certaine classe, vérifiez quel package la classe importe, puis accédez au package pour trouver la classe. Les classes qui n'ont pas besoin d'importer des packages doivent être situées dans java.lang. Accédez simplement à java.lang pour la trouver. .
Généralement, lorsque nous concevons une classe, nous devons remplacer la méthode égale de la classe parent. Lors de la réécriture de cette méthode, nous devons la concevoir selon les règles suivantes :
1. Réflexivité : pour toute valeur de référence X, la valeur de retour de x.equals(x) doit être vraie.
2. Symétrie : pour toute valeur de référence x, y, si et seulement si la valeur de retour de y.equals(x) est vraie, la valeur de retour de x.equals(y) doit être vraie ;
3. Transitivité : Si x.equals(y)=true, y.equals(z)=true, alors x.equals(z)=true
4. Cohérence : Si les objets participant à la comparaison ne changent pas, le résultat de la comparaison d'objets ne devrait pas non plus changer.
5. Non-nullabilité : pour toute valeur de référence non nulle X, la valeur de retour de x.equals(null) doit être fausse
Par exemple:
public class People { private String firstName ; private String lastName ; public String getFirstName() { return firstName ; } public void setLastName(String lastName) { this.lastName = lastName; } public int getAge() { return age } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; return false; Personnes autres = (Personnes) obj; if (age != other.age) return false if (firstName == null) { if (other.firstName != null) return false } else if; (!firstName.equals(other.firstName)) return false; if (lastName == null) { if (other.lastName != null) return false } else if (!lastName.equals(other.lastName)) return false; ; renvoie vrai ; }}
Dans cet exemple, nous stipulons qu'une personne est la même personne si son nom, son prénom et son âge sont les mêmes. Bien sûr, vous pouvez également ajouter d'autres attributs. Par exemple, le numéro d'identification doit être le même pour être jugé comme la même personne. Ensuite, vous pouvez ajouter le jugement du numéro d'identification dans la méthode égale !
Résumé : Pour comparer si deux objets sont égaux, nous utilisons la méthode equals(). Les conditions pour juger si deux objets sont égaux sont définies par nous après avoir réécrit l'implémentation de la méthode equals(), afin que la méthode equals() puisse être utilisé de manière plus flexible. Comparez deux objets de la même classe dans des classes différentes pour voir s'ils sont égaux.