Différence entre Equals / equals et == opérateur?

En supposant que les types de a et b sont des types de référence:

• En Java, == comparera toujours pour l’ identité – c’est-à-dire si les deux valeurs sont des références au même object. Ceci est aussi appelé égalité de référence . Java ne comporte aucune surcharge d’opérateur définie par l’utilisateur.

• En C # ça dépend. À moins qu’il y ait un opérateur surchargé qui le gère, == se comportera comme Java (c.-à-d. En comparant l’égalité de référence). Cependant, s’il y a une surcharge qui correspond aux types de compilation a et b (par exemple, s’ils sont tous les deux déclarés comme des chaînes), cette surcharge sera appelée. Cela peut se comporter comme il veut, mais il implémente généralement une égalité de valeur (c.-à a d. Que a et b peuvent se référer à des valeurs différentes mais égales et que cela retournerait toujours vrai).

Dans les deux langages, a.Equals(b) ou a.equals(b) appellera la méthode virtuelle Equals / equals par Object , sauf si une surcharge plus spécifique a été introduite par le type de compilation a . Cela peut ou peut ne pas être remplacé dans le type d’exécution de l’object auquel fait référence. Dans .NET et Java, l’implémentation dans Object vérifie également l’identité. Notez que cela dépend du type d’ exécution plutôt que du type de compilation dont dépend la résolution de la surcharge.

Bien sûr, si a est null vous obtiendrez une NullReferenceException / NullPointerException lorsque vous essayez d’appeler a.equals(b) ou a.Equals(b) .

L’opérateur == vérifie si deux objects sont exactement le même object, ce qui n’est pas le cas dans la plupart des cas. La méthode Equals sera capable de comparer l’object à la fois en interne

Exemple:

 class Mycar { ssortingng color; Mycar(ssortingng str) { color = str; } } Mycar a = new Mycar("blue"); Mycar b = new Mycar("blue"); a==b // Returns false a.Equals(b) // Returns true 

Cela dépend des types de a et b .

En particulier, Equals est une méthode virtuelle, de sorte que son comportement ne dépend pas des types de compilation a et b.

En Java, == comparera toujours par référence, ce qui n’est pas forcément ce que vous voulez, surtout pour les chaînes.

En C #, == peut être surchargé, mais n’est pas virtuel (c’est une méthode static ). Par conséquent, si a ou b sont déclarés comme object , ils seront comparés par référence, même si leur type actuel surcharge l’ operator == .

De plus, a.Equals(b) lancera une NullReferenceException ( NullPointerException en Java) si a est null .

 Ssortingng a = "toto".Subssortingng(0, 4); Ssortingng b = "toto"; Object aAsObj = a; Assert.IsTrue(a.Equals(b)); Assert.IsTrue(a == b); Assert.IsFalse(aAsObj == b); Assert.IsTrue(aAsObj.Equals(b)); 

Ce test passe en .NET, le truc est que Equals est une méthode, alors que == est une méthode static , donc aAsObj == b utilise

 static bool Object.operator==(object a, object b) //Reference comparison 

alors a == b utilise

 static bool Ssortingng.operator==(ssortingng a, ssortingng b) //Ssortingng comparison 

mais a.Equals(b) ou aAsObj.Equals(b) utilisent toujours:

 bool Ssortingng.Equals(Object obj) //Ssortingng comparison 

a == b renvoie true si les références contiennent la même valeur, c’est-à-dire qu’elles pointent vers le même object ou si elles sont toutes deux nulles.

La méthode equals() peut être remplacée pour comparer des objects. Par exemple, sur Ssortingngs , la méthode renvoie true si les chaînes contiennent la même chaîne, même si ce sont des objects de chaîne différents. Vous pouvez faire des choses similaires avec vos propres objects.

o.equals() lancera une exception si o est une référence nulle.

== est un opérateur fondamental dans la langue. L’opérateur == teste si deux variables de référence d’object font référence à la même instance exacte d’un object.

equals () est une méthode d’instance qui est fondamentalement définie par la classe java.lang.Object. La méthode, .equals () teste si les deux objects comparés sont équivalents, mais ils ne doivent pas nécessairement être la même instance du même object.

L’opérateur == vous donne toujours le même résultat, mais la méthode equals () vous donne une sortie en fonction de votre implémentation (logique implémentée).

1. Réflexif: Pour toute référence non nulle x, x.equals (x) devrait retourner true.

2. Symésortingque: Pour toute référence non nulle x et y, si x.equals (y) est vraie, alors y.equals (x) doit retourner true.

3. Transitive: Pour toute référence non nulle, x, y et z, si x.equals (y) est vrai, y.equals (z) est vrai, alors x.equals (z) doit retourner true.

4. Cohérence: pour toute référence non nulle x et y, les invocations multiples de x.equals (y) renvoient systématiquement true ou retournent systématiquement false, sans modifier les informations fournies pour les comparaisons d’égal à égal.

5. Pour toute référence non nulle x, x.equals (null) doit retourner false. REMARQUE: Si o1.equals (o2) est vrai, alors o1.hashcode () == o2.hashcode (), mais l’inverse peut être vrai ou non.

Exemples:

Entier i = nouvel entier (10); Entier j = i;

dans le code ci-dessus. i == j est vrai car i et j se réfèrent au même object.

Entier i = nouvel entier (10); Entier j = nouveau entier (10);

Dans le code ci-dessus, i == j est FALSE car, bien qu’ils aient tous deux la valeur 10, ce sont deux objects différents. Mais i.equals (j) retournera vrai.

Utilisation de la boxe automatique

Entier i = 10;
Entier j = 10;
Booléen b = (i == j);
System.out.println (b);

Cela renverra TRUE car les entiers compris entre -127 et 128 seront mis en pool. Dans ce cas, les deux objects sont identiques (la JVM ne va pas créer un nouvel object et le récupérera dans le pool).

La classe Ssortingng remplace la méthode equals, voici donc un exemple d’equals vs. == Ssortingng s1 = new Ssortingng (“abc”); Chaîne s2 = nouvelle chaîne (“abc”);

REMARQUE: les chaînes sont créées dans le pool de constantes Ssortingng. Lorsque nous créons comme Ssortingng s = ”abc”, il vérifie le pool en invoquant la méthode native intern () pour son existence dans le pool existant si aucune chaîne n’a été trouvée. créera un nouveau, mais si nous appelons un nouvel opérateur, il créera une nouvelle chaîne indépendamment de la vérification de l’existence du pool.

  public class SsortingngEqualityTest { public static void main(Ssortingng []a){ Ssortingng s1=new Ssortingng("abc"); Ssortingng s2=new Ssortingng("abc"); System.out.print("s1.equals(s2) :"+s1.equals(s2)+" s1==s2 :"); System.out.println(s1==s2); Ssortingng s3="abc"; Ssortingng s4="abc"; System.out.print("s3.equals(s4) :"+s1.equals(s2)+" s3==s4 :"); System.out.println(s3==s4); } } 

SORTIE: s1.equals (s2): vrai s1 == s2: faux s3.equals (s4): vrai s3 == s4: vrai

== utilise la référence d’un object, ou si un entier / float, etc., il compare le nombre réel. Techniquement, il compare simplement ce qui se trouve dans l’emplacement de mémoire. Alors que .equals utilise une méthode dans la classe d’object pour comparer des objects, il peut être remplacé pour vos classes individuelles. De même que les tableaux traitent aussi des références, il est également utile de ne pas utiliser array1[i] = array2[i] , utilisez arraycopy ou clone() . Je pense que .equals peut également être utilisé avec des tableaux

Supposons que nous avons a et b ou deux objects différents et que nous voulons comparer ces deux références d’object. Ensuite, nous utilisons l’opérateur == et lorsque nous utilisons a.equals(b) , il compare les valeurs de chaîne.

== vérifie la référence de l’object, en gros, il compare les codes de hachage. Equals utilise le contenu de l’object. Rappelez-vous, nous devons remplacer la méthode .equals conséquence dans notre classe.

== vérifie si les références pointent vers le même object en mémoire

À présent,

Bien que la méthode du code d’égalité dans la classe d’objects ne soit rien d’autre que de vérifier == pour les références, il peut être remplacé par l’ajout de vos propres vérifications d’égalité.

Dans les classes comme Ssortingng, la méthode remplacée vérifie si les littéraux de chaîne sont corrects ou non. Donc, fondamentalement, il peut être utilisé pour vérifier si la valeur est identique ou non.

==, Il ne retourne qu’une valeur de code de hachage en fonction de leurs adresses afin que les différentes adresses même si les chaînes ou toutes les données similaires lui retournent false …. Cette aide est complète pour les conditions, renvoie une valeur booléenne.