Expressions and Boolean Values in Java

A comparison in Java is an expression. Like any expression, it produces a value, and the value it produces is a boolean: either true or false. Java's relational operators are ==, !=, <, >, <=, and >=. Each one takes two operands and asks a yes-or-no question about them, such as whether the left side is less than the right side, or whether the two sides are equal.

Because a comparison yields a boolean, you can use it directly in an if statement, store it in a boolean variable, or combine it with another comparison. This article traces what happens inside these expressions for four kinds of values: numbers, characters, boolean values, and Strings. It also covers one special floating-point value, Double.NaN, which behaves differently from ordinary numbers.

Before looking at operators, trace what two String variables hold. In the diagram below, each variable a and b refers to its own String object. Both objects contain the same text, but they are separate objects stored in different places. This is the situation that makes == misleading for Strings.

The source states that == checks object storage location rather than string content. Here, a and b refer to different objects, so a == b asks whether they refer to the same object, and the answer is false. The text inside the two objects is identical, but == does not look at that text. The equals() method compares the contents, so a.equals(b) is true.

Relational operators can compare values of any numeric type. The six operators divide into two families. The equality operators, == and !=, ask whether two values are the same or different. The ordering operators, <, >, <=, and >=, ask how two values relate in order: less than, greater than, less than or equal to, or greater than or equal to.

Relational operators also compare char values. For characters, the operators < and > use the characters' numeric Unicode values. A char is compared through its number, so the ordering you get is the numeric ordering of those codes. That is why 'a' < 'b' is true: the code for 'a' is smaller than the code for 'b'.

The ordering is numeric, not alphabetical in the everyday sense. The source notes that all uppercase letters come before all lowercase letters. So 'Z' is less than 'a', even though a dictionary would list a before Z. The diagram shows why: every uppercase letter has a smaller code than every lowercase letter. A learner who expects alphabetical behavior should check the codes instead.

The operators == and != can also compare boolean values. This matters most when the operands are themselves comparison results. Each comparison inside the expression is evaluated first and becomes true or false, and then the outer operator compares those two boolean results. Read the expression in that order.

When you want to know whether two Strings contain the same text, the correct tool is equals(). When you want to know how two Strings order relative to each other, use compareTo(). The source is clear that String contents should be compared with these methods. The == operator checks object storage location rather than string content, so it answers a different question from the one most programs need answered.

Double.NaN is a special floating-point value that means not a number. It is the result of some arithmetic, for example dividing zero by zero with doubles. Because NaN is special, you cannot detect it by comparing against it with ==. An expression like x == Double.NaN returns false even when x is NaN. The correct way to test is Double.isNaN(x), which returns true exactly when x is NaN.