2.2 Boolean Expressions

1. Relational operators produce true or false

A relational operator compares two values. An expression that uses one evaluates to a Boolean value, true or false 2.2.A.3. You can print that value or store it in a boolean variable.

Operator	Meaning	Example	Value
==	equal to	4 == 4	true
!=	not equal to	4 != 4	false
<	less than	3 < 8	true
>	greater than	3 > 8	false
<=	less than or equal to	5 <= 5	true
>=	greater than or equal to	2 >= 7	false

int age = 16;
boolean canDrive = age >= 16;
boolean canVote = age >= 18;
System.out.println(canDrive);
System.out.println(canVote);
System.out.println(age != 16);

Output:

true
false
false

Watch out: =<, => and <> are not Java operators. The equals sign always comes second.

2. Comparing numbers with <, >, <= and >=

The operators <, >, <= and >= compare numeric values to find their relationship 2.2.A.2. They work with int and double values, and you can mix the two types: Java widens the int to a double before comparing.

The arithmetic on each side happens first, with the normal Java rules. That makes integer division a classic trap:

int goals = 7;
int games = 2;
System.out.println(goals / games > 3);
System.out.println(goals / games >= 3);
System.out.println((double) goals / games > 3);

Output:

false
true
true

goals / games is 7 / 2, which is 3 in integer division, and 3 > 3 is false. Casting one operand to double gives 3.5, and 3.5 > 3 is true.

Watch out: a range such as “between 0 and 10” cannot be written as 0 < x < 10 in Java. The first comparison gives a boolean, and a boolean cannot be compared with a number.

int x = 5;
boolean inRange = 0 < x < 10;

error: bad operand types for binary operator '<'

You will join two comparisons with && in Topic 2.5.

3. == and != with primitive values

The operators == and != check whether two values are the same 2.2.A.1. With primitive types (int, double, boolean), they compare the actual primitive values.

int lives = 3;
int startLives = 3;
boolean gameOver = false;
System.out.println(lives == startLives);
System.out.println(lives != 0);
System.out.println(gameOver == false);

Output:

true
true
true

Watch out (= versus ==): one equals sign is assignment, two are comparison. Using = where Java expects a Boolean expression is a compile error for int values:

int lives = 3;
if (lives = 0) {
    System.out.println("Game over");
}

error: incompatible types: int cannot be converted to boolean

Watch out (double values): round-off error can make two values that should be equal compare as different.

double total = 0.1 + 0.2;
System.out.println(total == 0.3);
System.out.println(total);

Output:

false
0.30000000000000004

4. == and != with reference types

With reference types, == and != compare the object references, not the contents of the objects 2.2.A.1. A reference tells Java where an object is. Two references are == only when they refer to the same object.

String a = new String("goal");
String b = new String("goal");
String c = a;
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a.equals(b));

Output:

false
true
true

• a == b is false: new created two separate objects, even though both hold the letters “goal”.
• a == c is true: c holds a copy of the reference in a, so both refer to the same object.
• a.equals(b) is true: equals compares the characters.

Watch out: this is the most common String trap on the AP® exam. To ask “do these strings have the same characters?”, use equals, never ==. Topic 2.6 goes deeper into comparing object references.

5. Store the result and reuse it

Because a relational expression evaluates to a Boolean value, you can store the result in a boolean variable with a clear name. This makes later code easier to read.

double temperature = 38.4;
boolean hasFever = temperature >= 38.0;
System.out.println("Fever: " + hasFever);

Output:

Fever: true

Read hasFever = temperature >= 38.0 from right to left: first the comparison gives true, then = stores true in hasFever.