The ==
and !=
operators are binary operators that evaluate to true
or false
depending on whether the operands are equal. The ==
operator gives true
if the operands are equal and false
otherwise. The !=
operator gives false
if the operands are equal and true
otherwise.
These operators can be used operands with primitive and reference types, but the behavior is significantly different. According to the JLS, there are actually three distinct sets of these operators:
==
and !=
operators.==
and !=
operators.==
and !=
operators.However, in all cases, the result type of the ==
and !=
operators is boolean
.
==
and !=
operatorsWhen one (or both) of the operands of an ==
or !=
operator is a primitive numeric type (byte
, short
, char
, int,
long
, float
or double
), the operator is a numeric comparison. The second operand must be either a primitive numeric type, or a boxed numeric type.
The behavior other numeric operators is as follows:
byte
, short
or char
, it is promoted to an int
.int
or long
then the values are tested to see if they are identical.float
or double
then:
+0.0
and -0.0
) are treated as equalNaN
value is treated as not equals to anything, andNote: you need to be careful when using ==
and !=
to compare floating point values.
==
and !=
operatorsIf both operands are boolean
, or one is boolean
and the other is Boolean
, these operators the Boolean ==
and !=
operators. The behavior is as follows:
Boolean
, it is unboxed.A | B | A == B | A != B |
---|---|---|---|
false | false | true | false |
false | true | false | true |
true | false | false | true |
true | true | true | false |
There are two "pitfalls" that make it advisable to use ==
and !=
sparingly with truth values:
If you use ==
or !=
to compare two Boolean
objects, then the Reference operators are used. This may give an unexpected result; see Pitfall: using == to compare primitive wrappers objects such as Integer
The ==
operator can easily be mistyped as =
. For most operand types, this mistake leads to a compilation error. However, for boolean
and Boolean
operands the mistake leads to incorrect runtime behavior; see Pitfall - Using '==' to test a boolean
==
and !=
operatorsIf both operands are object references, the ==
and !=
operators test if the two operands refer to the same object. This often not what you want. To test if two objects are equal by value, the .equals()
method should be used instead.
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
Warning: using ==
and !=
to compare String
values is incorrect in most cases; see http://www.riptutorial.com/java/example/16290/pitfall--using----to-compare-strings . A similar problem applies to primitive wrapper types; see http://www.riptutorial.com/java/example/8996/pitfall--using----to-compare-primitive-wrappers-objects-such-as-integer .
JLS 15.21.1 states the following:
If either operand is
NaN
, then the result of==
isfalse
but the result of!=
istrue
. Indeed, the testx != x
istrue
if and only if the value ofx
isNaN
.
This behavior is (to most programmers) unexpected. If you test if a NaN
value is equal to itself, the answer is "No it isn't!". In other words, ==
is not reflexive for NaN
values.
However, this is not a Java "oddity", this behavior is specified in the IEEE 754 floating-point standards, and you will find that it is implemented by most modern programming languages. (For more information, see http://stackoverflow.com/a/1573715/139985 ... noting that this is written by someone who was "in the room when the decisions were made"!)