Articles d'amélioration Java ---- résumé de la méthode equals()

equals()

Il existe cette méthode equals() dans la super classe Object. Cette méthode est principalement utilisée pour comparer si deux objets sont égaux. Le code source de cette méthode est le suivant :

public boolean equals(Object obj) {    return (this == obj);
    }

Nous savons que tous les objets ont une identification (adresse mémoire) et un statut (données), et "==" compare les adresses mémoire des deux objets, alors utilisez La méthode equals() de Object compare si les adresses mémoire de deux objets sont égales, c'est-à-dire que si object1.equals(object2) est vrai, cela signifie que égal1 et égal2 font réellement référence au même objet. Bien que parfois la méthode equals() de Object puisse répondre à certaines de nos exigences de base, nous devons être conscients que la plupart du temps nous comparons deux objets, à l'heure actuelle, la méthode equals() de Object ne peut pas être utilisée. Dans le JDK précédent, les classes d'encapsulation telles que String et Math ont réécrit la méthode equals().

Ce qui suit est la méthode equals() de String :

public boolean equals(Object anObject) {    if (this == anObject) {        return true;
    }    if (anObject instanceof String) {
        String anotherString = (String)anObject;        
        int n = count;        
        if (n == anotherString.count) {        
        char v1[] = value;        
        char v2[] = anotherString.value;        
        int i = offset;        
        int j = anotherString.offset;        
        while (n-- != 0) {            
        if (v1[i++] != v2[j++])            
        return false;
        }       
         return true;
        }
    }    return false;
    }

Pour ce segment de code : if (v1[i] != v2[j]) return false ; Voyez clairement que la méthode equals() de String effectue une comparaison de contenu, pas une comparaison de référence. Quant aux autres classes d’encapsulation, elles sont similaires.

Dans la spécification Java, son utilisation de la méthode equals() doit suivre les règles suivantes :

La méthode equals est sur un objet non nul référence Réalisez la relation d'égalité :

1. Réflexivité : pour toute valeur de référence non nulle x, x.equals(x) doit renvoyer true.

2. Symétrie : pour toute valeur de référence non nulle x et y, x.equals(y) doit renvoyer vrai si et seulement si y.equals(x) renvoie vrai.

3. Transitivité : Pour toute valeur de référence non nulle x, y et z, si x.equals(y) renvoie vrai et y.equals(z) renvoie vrai, alors x.equals(z ) Devrait renvoyer vrai.

4. Cohérence : pour toutes les valeurs de référence non nulles x et y, appeler x.equals(y) plusieurs fois renvoie toujours vrai ou renvoie toujours faux, à condition que les informations utilisées dans la comparaison égale sur l'objet n'a pas été révisé.

5. Pour toute valeur de référence non nulle x, x.equals(null) doit renvoyer false.

Pour les règles ci-dessus, il est préférable que nous les respections pendant l'utilisation, sinon des erreurs inattendues se produiront.

Pour comparer en java, il faut choisir la méthode de comparaison appropriée en fonction du type de comparaison :

1) Dans le champ objet, utilisez le méthode égale.
2) Énumération de type sécurisé, utilisez égal ou ==.
3) Champs d'objet éventuellement nuls : utilisez == et égal.
4) Champ Array : utilisez Arrays.equals.
5) Types de données primitifs sauf float et double : utilisez ==.
6) Type Float : utilisez Float.foatToIntBits pour convertir en type int, puis utilisez ==.
7) Type double : utilisez Double.doubleToLongBit pour convertir en type long, puis utilisez ==.

Pour savoir pourquoi 6) et 7) doivent être convertis, nous pouvons nous référer à la méthode equals() de leurs classes d'encapsulation correspondantes. la classe Float :

public boolean equals(Object obj) {    return (obj instanceof Float)
           && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }

La raison est qu'il y a deux points mentionnés :

However, there are two exceptions:If f1 and f2 both representFloat.NaN, then the equals method returnstrue, 
even though Float.NaN==Float.NaNhas the value false.If <code>f1 represents +0.0f whilef2 represents -0.0f, or vice
versa, the equal test has the valuefalse, even though 0.0f==-0.0f
has the value true.

Utilisez getClass dans equals() pour le jugement de type

Nous remplaçons la méthode equals() Il est généralement recommandé d'utiliser getClass pour le jugement de type au lieu de instanceof. Nous savons tous que la fonction d'instanceof est de déterminer si l'objet de gauche est une instance de la classe de droite et de renvoyer des données de type booléen. Il peut être utilisé pour déterminer si l'instance de la sous-classe en héritage est l'implémentation de la classe parent. Faites attention à la phrase suivante : Elle peut être utilisée pour déterminer si l'instance de la sous-classe en héritage est l'implémentation de la classe parent. C'est cette phrase qui pose problème. Examinons d'abord l'exemple suivant (extrait de « Code de haute qualité : 151 suggestions pour améliorer les programmes Java »).

Classe parent : Personne

public class Person {    
protected String name;    
public String getName() {        
return name;
    }    
    public void setName(String name) {        
    this.name = name;
    }    
    public Person(String name){        
    this.name = name;
    }    
    public boolean equals(Object object){        
    if(object instanceof Person){
            Person p = (Person) object;            
            if(p.getName() == null || name == null){                
            return false;
            }            
            else{                
            return name.equalsIgnoreCase(p.getName());
            }
        }        
        return false;
    }
}

Sous-classe : Employé

public class Employee extends Person{    private int id;
    
    public int getId() {        
    return id;
    }

    public void setId(int id) {        
    this.id = id;
    }

    public Employee(String name,int id){        
    super(name);        
    this.id = id;
    }    
    /**
     * 重写equals()方法
     */
    public boolean equals(Object object){        
    if(object instanceof Employee){            
    Employee e = (Employee) object;            
    return super.equals(object) && e.getId() == id;
        }        
        return false;
    }
}

La classe parent ci-dessus Personne et la sous-classe Employé réécrivent égales (), mais Employé Il a un attribut id de plus que la classe parent. Le programme de test est le suivant :

public class Test {    public static void main(String[] args) {
        Employee e1 = new Employee("chenssy", 23);
        Employee e2 = new Employee("chenssy", 24);
        Person p1 = new Person("chenssy");
        
        System.out.println(p1.equals(e1));
        System.out.println(p1.equals(e2));
        System.out.println(e1.equals(e2));
    }
}

Ce qui précède définit deux employés et une personne ordinaire. Bien qu'ils portent le même nom, ce ne sont certainement pas la même personne, donc logiquement, les résultats de sortie devraient tous être faux. , mais cela s’est retourné contre vous. Le résultat est : vrai, vrai, faux.

Il est très facile pour nous de comprendre que e1!=e2, car ils doivent non seulement comparer les noms, mais aussi les identifiants. Mais p1 est égal à e1 et e2. C’est très étrange, car e1 et e2 sont évidemment deux classes différentes, mais pourquoi cela se produit-il ? Tout d'abord, p1.equals(e1) appelle la méthode equals de p1. Cette méthode utilise le mot-clé instanceof pour vérifier si e1 est une classe Person. Ici, nous examinons instanceof : pour déterminer si l'objet de gauche est une instance de la classe. à droite. Vous pouvez également Utilisé pour déterminer si l'instance de la sous-classe en héritage est l'implémentation de la classe parent. Il existe une relation d'héritage entre eux, donc ils reviendront certainement vrai, et leurs noms sont les mêmes, donc le résultat sera certainement vrai.

La situation ci-dessus se produit donc parce que le mot-clé instanceof est utilisé, ce qui est très facile à "exploiter". Par conséquent, il est recommandé d’utiliser getClass pour le jugement de type lors de la substitution d’égaux. Utilisez plutôt instanceof.

Ce qui précède est le résumé de l'article d'amélioration Java ---- méthode equals() Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www. php.cn) !