Java Language Les opérateurs d'égalité (==,! =)


Exemple

Les opérateurs == et != Sont des opérateurs binaires dont la valeur est true ou false selon que les opérandes sont égaux ou non. L'opérateur == donne true si les opérandes sont égaux et false sinon. L'opérateur != Donne false si les opérandes sont égaux et true sinon.

Ces opérateurs peuvent être utilisés avec des opérandes avec des types primitifs et de référence, mais le comportement est sensiblement différent. Selon le JLS, il existe en réalité trois ensembles distincts de ces opérateurs:

  • Les booléens == et les opérateurs != .
  • Les opérateurs numériques == et != .
  • Les opérateurs de référence == et != .

Cependant, dans tous les cas, le type de résultat des opérateurs == et != Est boolean .

Les opérateurs numériques == et !=

Lorsque l'un (ou les deux) opérandes d'un opérateur == ou != Est un type numérique primitif ( byte , short , char , int, long , float ou double ), l'opérateur est une comparaison numérique. Le second opérande doit être un type numérique primitif ou un type numérique encadré.

Le comportement des autres opérateurs numériques est le suivant:

  1. Si l'un des opérandes est un type encadré, il n'est pas enregistré.
  2. Si l'une des opérandes maintenant un byte , à short ou char , il est promu à un int .
  3. Si les types des opérandes ne sont pas les mêmes, l'opérande avec le type "plus petit" est promu au type "plus grand".
  4. La comparaison est ensuite effectuée comme suit:
    • Si les opérandes promus sont int ou long les valeurs sont testées pour voir si elles sont identiques.
    • Si les opérandes promus sont float ou double alors:
      • les deux versions de zéro ( +0.0 et -0.0 ) sont considérés comme égaux
      • une valeur NaN est traitée comme non égal à rien, et
      • les autres valeurs sont égales si leurs représentations IEEE 754 sont identiques.

Remarque: vous devez faire attention lorsque vous utilisez == et != Pour comparer des valeurs en virgule flottante.

Le booléen == et les opérateurs !=

Si les deux opérandes sont boolean , ou l'un est boolean et l'autre Boolean , ces opérateurs sont les opérateurs booléens == et != . Le comportement est le suivant:

  1. Si l'un des opérandes est un Boolean , il n'est pas enregistré.
  2. Les opérandes unboxed sont testés et le résultat booléen est calculé selon la table de vérité suivante
UNE B A == B A! = B
faux faux vrai faux
faux vrai faux vrai
vrai faux faux vrai
vrai vrai vrai faux

Il y a deux «pièges» qui recommandent d'utiliser == et != Avec parcimonie avec des valeurs de vérité:

La référence == et les opérateurs !=

Si les deux opérandes sont des références d'objet, les opérateurs == et != Testent si les deux opérandes font référence au même objet . Ce n'est souvent pas ce que vous voulez. Pour tester si deux objets sont égaux en valeur , la méthode .equals() doit être utilisée à la place.

String s1 = "We are equal";
String s2 = new String("We are equal");

s1.equals(s2); // true

// WARNING - don't use == or != with String values
s1 == s2;      // false

Attention: utiliser == et != Pour comparer les valeurs de String est incorrect dans la plupart des cas; voir http://www.riptutorial.com/java/example/16290/pitfall--using----to-compare-strings . Un problème similaire s'applique aux types d'encapsuleurs primitifs. voir http://www.riptutorial.com/java/example/8996/pitfall--using----to-compare-primitive-wrappers-objects-such-as-integer .

À propos des bordures NaN

JLS 15.21.1 indique ce qui suit:

Si l'un des opérandes est NaN , le résultat de == est false mais le résultat de != Est true . En effet, le test x != x est true si et seulement si la valeur de x est NaN .

Ce comportement est (pour la plupart des programmeurs) inattendu. Si vous testez si une valeur NaN est égale à elle-même, la réponse est "Non, ça ne l'est pas!". En d'autres termes, == n'est pas réflexif pour les valeurs NaN .

Cependant, il ne s'agit pas d'une "bizarrerie" Java, ce comportement est spécifié dans les normes à virgule flottante IEEE 754 et vous constaterez qu'il est implémenté par la plupart des langages de programmation modernes. (Pour plus d'informations, voir http://stackoverflow.com/a/1573715/139985 ... notant que ceci est écrit par quelqu'un qui était "dans la pièce lorsque les décisions ont été prises"!)