Je voulais clarifier si je comprends bien:
==
est une comparaison de référence, c.-à-d. que les deux objets pointent vers le même emplacement mémoire.equals()
évalue à la comparaison des valeurs dans les objets
java
identity
equality
object-comparison
brainydexter
la source
la source
.equals()
à un équivalent significatifRéponses:
En général, la réponse à votre question est "oui", mais ...
.equals(...)
ne fera que comparer ce qu'il est écrit pour comparer, ni plus, ni moins.equals(Object o)
méthode de la classe parent la plus proche qui a remplacé cette méthode.Object#equals(Object o)
méthode. Selon l'API Object, c'est la même chose que==
; c'est-à-dire qu'elle renvoie vrai si et seulement si les deux variables font référence au même objet, si leurs références sont identiques. Ainsi, vous testerez l'égalité des objets et non l'égalité fonctionnelle .hashCode
si vous passez outreequals
afin de ne pas «rompre le contrat». Selon l'API, le résultat renvoyé par lahashCode()
méthode pour deux objets doit être le même si leursequals
méthodes montrent qu'elles sont équivalentes. L'inverse n'est pas nécessairement vrai.la source
==
vérifie la référence de la mémoire, alors pourquoi ai-je ce comportement étrange dans [this] [1] [1]: docs.google.com/document/d/… Je m'attendais à ce que la sortie soit vraie. peut effacer mes confusionsThe equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
<br/>Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
( docs.oracle.com/javase/7/docs/api/java/lang/… )En ce qui concerne la classe String:
La méthode equals () compare la "valeur" à l'intérieur des instances de String (sur le tas), que les deux références d'objet se réfèrent ou non à la même instance de String. Si deux références d'objet de type String font référence à la même instance de String, c'est parfait! Si les deux références d'objet font référence à deux instances de chaîne différentes .. cela ne fait aucune différence. C'est la "valeur" (c'est-à-dire le contenu du tableau de caractères) à l'intérieur de chaque instance de chaîne qui est comparée.
En revanche, l' opérateur "==" compare la valeur de deux références d'objet pour voir si elles se réfèrent à la même instance de chaîne . Si la valeur des deux références d'objet "fait référence à" la même instance de chaîne, le résultat de l'expression booléenne serait "vrai" .. duh. Si, d'autre part, la valeur des deux références d'objet "fait référence à" différentes instances de String (même si les deux instances de String ont des "valeurs" identiques, c'est-à-dire que le contenu des tableaux de caractères de chaque instance de String est le même), la le résultat de l'expression booléenne serait "faux".
Comme pour toute explication, laissez-la pénétrer.
J'espère que cela clarifie un peu les choses.
la source
String
s, la==
référence est également égale, oui, mais cela fonctionne généralement (comme dans deuxString
s avec le même contenu sera généralement l' un==
pour l'autre), en raison de la façon dont Java gèreString
s. Ce ne sera pas toujours, et c'est certainement une mauvaise pratique, mais c'est une erreur courante, en particulier de la part de personnes venant d'autres langues.String
la construction à partir d'un littéral de chaîne sera ajoutée à quelque chose appeléString constant pool
, par exemple lesString s1 = "someString"; String s2 = "someString;"
deuxs1
&s2
partageront la même référence.s1 == s2
reviendra vrai. Mais s'ils ont été construits viaString constructor
, par exemple,String s1 = new String("someString"); String s2 = new String("someString");
ils ne partageront pas la même référence.s1 == s2
retournera faux.Il y a quelques petites différences selon que vous parlez de "primitives" ou de "types d'objets"; la même chose peut être dite si vous parlez de membres "statiques" ou "non statiques"; vous pouvez également mélanger tout ce qui précède ...
Voici un exemple (vous pouvez l'exécuter):
Vous pouvez comparer les explications de "==" (Opérateur d'égalité) et ".equals (...)" (méthode dans la classe java.lang.Object) via ces liens:
la source
La différence entre == et égal m'a confondu pendant un certain temps jusqu'à ce que je décide de l'examiner de plus près. Beaucoup d'entre eux disent que pour comparer une chaîne, vous devez utiliser
equals
et non==
. J'espère que dans cette réponse je pourrai faire la différence.La meilleure façon de répondre à cette question sera de vous poser quelques questions. Commençons donc:
Quelle est la sortie pour le programme ci-dessous:
si tu le dis,
Je dirai que vous avez raison, mais pourquoi avez-vous dit cela ? et si vous dites que la sortie est,
Je dirai que vous vous trompez mais je vous demanderai toujours pourquoi vous pensez que c'est vrai?
Ok, essayons de répondre à celui-ci:
Quelle est la sortie pour le programme ci-dessous:
Maintenant, si vous dites,
Je dirai que tu as tort mais pourquoi est-ce mal maintenant ? la sortie correcte pour ce programme est
Veuillez comparer le programme ci-dessus et essayer d'y penser.
D'accord. Maintenant, cela pourrait aider (veuillez lire ceci: imprimer l'adresse de l'objet - pas possible mais nous pouvons toujours l'utiliser.)
pouvez-vous juste essayer de penser à la sortie des trois dernières lignes dans le code ci-dessus: pour moi, ideone l'a imprimé ( vous pouvez vérifier le code ici ):
Oh! Maintenant, vous voyez que l' identitéHashCode (mangue) est égale à l'identitéHashCode (mangue2) Mais ce n'est pas égal à l'identitéHashCode (mangue3)
Même si toutes les variables de chaîne - mango, mango2 et mango3 - ont la même valeur, qui est "mango",
identityHashCode()
n'est pas toujours la même pour tous.Maintenant, essayez de décommenter cette ligne
// mango2 = "mang";
et de l'exécuter à nouveau cette fois, vous verrez que les troisidentityHashCode()
sont différents. Hmm c'est un indice utilenous savons que si
hashcode(x)=N
ethashcode(y)=N
=>x is equal to y
Je ne sais pas comment Java fonctionne en interne, mais je suppose que c'est ce qui s'est passé lorsque j'ai dit:
java a créé une chaîne
"mango"
qui a été pointée (référencée) par la variablemango
quelque chose comme çaMaintenant dans la ligne suivante quand j'ai dit:
Il a en fait réutilisé la même chaîne
"mango"
qui ressemble à ceciLa mangue et mango2 pointent vers la même référence. Maintenant, quand j'ai dit
Il a en fait créé une toute nouvelle référence (chaîne) pour "mangue". qui ressemble à ceci,
et c'est pourquoi quand je mets les valeurs pour
mango == mango2
, ça metstrue
. et quand je mets la valeur pourmango3 == mango2
, elle s'éteintfalse
(même lorsque les valeurs sont les mêmes).et lorsque vous avez commenté la ligne,
// mango2 = "mang";
cela a en fait créé une chaîne "mang" qui a transformé notre graphique comme ceci:C'est pourquoi le IdentityHashCode n'est pas le même pour tous.
J'espère que cela vous aide les gars. En fait, je voulais générer un cas de test où == échoue et equals () réussit. N'hésitez pas à commenter et à me faire savoir si je me trompe.
la source
mango == mango2
cela se produit parce que vous n'avez pas créé enmango2
tant que nouvel objet String et que vous avez simplement fait directement référence"mango"
?À votre santé :-)
la source
Vous devrez remplacer la fonction equals (ainsi que d'autres) pour l'utiliser avec des classes personnalisées.
La méthode equals compare les objets.
L'
==
opérateur binaire compare les adresses mémoire.la source
== et .equals () font référence au même objet si vous ne remplacez pas .equals ().
C'est votre souhait ce que vous voulez faire une fois que vous remplacez .equals (). Vous pouvez comparer l'état de l'objet appelant avec l'état de l'objet passé ou vous pouvez simplement appeler super.equals ()
la source
==
est un opérateur etequals()
est une méthode .Les opérateurs sont généralement utilisés pour les comparaisons de type primitif et sont donc
==
utilisés pour la comparaison d'adresses mémoire et laequals()
méthode est utilisée pour comparer les objets .la source
la source
N'oubliez pas que cela
.equals(...)
doit être implémenté par la classe que vous essayez de comparer. Sinon, il n'y a pas grand chose à dire; la version de la méthode pour la classe Object fait la même chose que l'opération de comparaison: Object # est égal .La seule fois où vous voulez vraiment utiliser l'opérateur de comparaison pour les objets est lorsque vous comparez des énumérations. En effet, il n'y a qu'une seule instance d'une valeur Enum à la fois. Par exemple, étant donné l'énumération
Vous n'aurez jamais plus d'une instance
A
à la fois, et la même chose pourB
etC
. Cela signifie que vous pouvez réellement écrire une méthode comme ceci:Et vous n'aurez aucun problème.
la source
Lorsque vous évaluez le code, il est très clair que (==) compare en fonction de l'adresse mémoire, tandis que égal à (Object o) compare hashCode () des instances. C'est pourquoi il est dit de ne pas rompre le contrat entre equals () et hashCode () si vous ne rencontrez pas de surprises plus tard.
la source
Voici une règle générale pour la différence entre
relational operator ==
etthe method .equals()
.object1 == object2
compare si les objets référencés par object1 et object2 se réfèrent au même emplacement mémoire dans Heap .object1.equals(object2)
compare les valeurs de object1 et object2 quel que soit leur emplacement en mémoire .Cela peut être bien démontré en utilisant String
Scénario 1
Scénario 2
Cette comparaison de chaînes pourrait être utilisée comme base pour comparer d'autres types d'objets.
Par exemple, si j'ai une classe Person , je dois définir la base de critères sur laquelle je comparerai deux personnes . Disons que cette classe de personnes a des variables d'instance de taille et de poids.
Donc, créer des objets personne
person1 and person2
et comparer ces deux en utilisant la fonction.equals()
J'ai besoin de remplacer la méthode égal de la classe personne pour définir en fonction des variables d'instance (hauteur ou poids) de la comparaison.Cependant, le
== operator will still return results based on the memory location of the two objects(person1 and person2)
.Pour faciliter la généralisation de cette comparaison d'objet personne, j'ai créé la classe de test suivante. L'expérimentation de ces concepts révélera des tonnes de faits .
Le résultat de cette exécution de classe est:
la source
Notez également que
.equals()
contient normalement==
pour le test car c'est la première chose que vous souhaitez tester si vous souhaitez tester si deux objets sont égaux.Et
==
regarde les valeurs des types primitifs, pour les objets, il vérifie la référence.la source
== opérateur toujours référence est comparée. Mais en cas de
cela dépend de l'implémentation si nous sommes remplacés par la méthode égale à celle qui compare l'objet sur la base de l'implémentation donnée dans la méthode substituée.
dans le code ci-dessus, les objets obj et obj1 contiennent les mêmes données mais la référence n'est pas la même, donc égal retourne false et == également. mais si nous avons remplacé la méthode égale à
savoir vérifier, il retournera vrai et faux pour le même cas que nous avons remplacé
il compare l'objet sur la base du contenu (id) de l'objet
toujours comparer les références d'objet.
la source
La principale différence entre == et equals () est
1) == est utilisé pour comparer les primitives.
Par exemple :
2) equals () est utilisé pour comparer des objets. Par exemple :
la source
==
peut être utilisé dans de nombreux types d'objets, mais vous pouvez l'utiliserObject.equals
pour n'importe quel type, en particulier les chaînes et les marqueurs Google Map.la source
---- Sortie ----- vrai faux vrai
la source
Il peut être utile d'ajouter que pour les objets wrapper pour les types primitifs - c'est-à-dire Int, Long, Double - == retournera vrai si les deux valeurs sont égales.
En revanche, mettre les deux Longs ci-dessus dans deux ArrayLists séparés, égaux les voit comme les mêmes, mais pas ==.
la source
Long a = 128l; Long b = 128l; System.out.println(a == b);
Le pool de chaînes (alias interning ) et le pool d'entiers estompent davantage la différence et peuvent vous permettre d'utiliser
==
des objets dans certains cas au lieu de.equals
Cela peut vous donner de meilleures performances (?), Au prix d'une plus grande complexité.
Par exemple:
Compromis de complexité: les éléments suivants peuvent vous surprendre:
Je vous conseille de vous tenir à l'écart de cette micro-optimisation, et de toujours l' utiliser
.equals
pour les objets, et==
pour les primitives:la source
Bref, la réponse est "oui".
En Java, l'
==
opérateur compare les deux objets pour voir s'ils pointent vers le même emplacement mémoire; tandis que la.equals()
méthode compare en fait les deux objets pour voir s'ils ont la même valeur d'objet.la source
Fondamentalement,
==
compare si deux objets ont la même référence sur le tas, donc à moins que deux références soient liées au même objet, cette comparaison sera fausse.equals()
est une méthode héritée de laObject
classe. Cette méthode compare par défaut si deux objets ont la même référence. Ça veut dire:object1.equals(object2)
<=>object1 == object2
Cependant, si vous souhaitez établir l'égalité entre deux objets de la même classe, vous devez remplacer cette méthode. Il est également très important de remplacer la méthode
hashCode()
si vous avez remplacéequals()
.Implémenter
hashCode()
lors de l'établissement de l'égalité fait partie du contrat d'objet Java. Si vous travaillez avec des collections et que vous ne les avez pas implémentéeshashCode()
, Strange Bad Things peut se produire:null
sera imprimé après l'exécution du code précédent si vous ne l'avez pas implémentéhashCode()
.la source
Étant donné que Java ne prend pas en charge la surcharge des opérateurs, == se comporte de la même manière pour chaque objet, mais equals () est une méthode qui peut être remplacée en Java et la logique de comparaison des objets peut être modifiée en fonction des règles métier.
La principale différence entre == et equals en Java est que "==" est utilisé pour comparer les primitives tandis que la méthode equals () est recommandée pour vérifier l'égalité des objets.
La comparaison de chaînes est un scénario courant d'utilisation à la fois de la méthode == et de l'égalité. Étant donné que la classe java.lang.String remplace la méthode equals, elle renvoie true si deux objets String contiennent le même contenu, mais == ne renvoie true que si deux références pointent vers le même objet.
Voici un exemple de comparaison de deux chaînes en Java pour l'égalité en utilisant la méthode == et equals (), ce qui effacera certains doutes:
la source