Boolean Expressions

In Topic 2.1 you described algorithms that make decisions: “If the guess matches the secret number, say You win.” Before a program can make that choice, it has to answer the question inside it: does the guess match? Every program you have written so far computes numbers and text. Now you need a way to compute an answer to a yes-or-no question.

Java already has a type for yes-or-no answers. Recall from Topic 1.2 that boolean is a primitive type with exactly two values, true and false. So what is needed is a way to write a question whose answer Java works out as one of those two values.

That is what a comparison does. You write two values with a symbol between them, and Java checks how the two values relate. Think of it like asking a referee a question that can only be answered “yes” or “no”: Java never answers “maybe” or “7”. The answer is always true or false.

A relational operator is a symbol that compares two values and produces a boolean result. The first two relational operators ask about sameness:

Both are two characters typed with no space between them. == is two equals signs; != is an exclamation mark followed by an equals sign. Java uses two equals signs because a single = already has a job: it is the assignment operator from Topic 1.4, which stores a value. == stores nothing; it only asks.

An expression that Java evaluates to true or false is called a Boolean expression. guess == secret is a Boolean expression. So is guess != secret. Every expression built with a relational operator is a Boolean expression, because the operator’s result is always a boolean value. (Boolean is capitalized here because, like the type boolean, it is named after the mathematician George Boole.)

int guess = 7;
int secret = 7;
System.out.println(guess == secret);
System.out.println(guess != secret);
guess = 4;
System.out.println(guess == secret);
System.out.println(guess != secret);

true
false
false
true

The values on each side of == are primitive values here, so Java compares those values directly: is the int in guess the same number as the int in secret? Now vary the types. The next example compares an int with a double, compares two boolean values, and stores a result in a boolean variable instead of printing it right away.

int boxes = 3;
double weight = 3.0;
boolean sameNumber = boxes == weight;
System.out.println(sameNumber);
boolean doorOpen = true;
System.out.println(doorOpen != false);

true
true

int guess = 7;
boolean correct = guess = 7;
System.out.println(correct);

error: incompatible types: int cannot be converted to boolean

int lives = 3;
int maxLives = 5;
System.out.println(lives == maxLives);
System.out.println(lives != maxLives);
lives = 5;
System.out.println(lives == maxLives);
boolean roomForMore = lives != maxLives;
System.out.println(roomForMore);

false
true
true
false

int pin = 1234;
int entered = 1243;
boolean match = entered = pin;
System.out.println(match);

int pin = 1234;
int entered = 1243;
boolean match = entered == pin;
System.out.println(match);

Many decisions do not ask “the same or not?” They ask “how big?” A test is passed with a score of at least 70. A ride lets you on if you are taller than a line on the sign. A coupon works if the total is under a limit. == and != cannot answer these, because a score of 85 is not equal to 70 and yet it passes.

For questions about which number is larger, Java has four more relational operators. You know the ideas from math; only the symbols for “or equal” are typed differently, because a keyboard has no ≤ or ≥ key, so Java spells them with two characters:

For <= and >=, the angle bracket comes first and the equals sign second, written together with no space: say “less than or equal,” in that order, and type it in that order. These four operators work on numbers (int and double), because only numbers have a “larger” and “smaller.” Like == and !=, each one produces a boolean.

int score = 70;
System.out.println(score > 70);
System.out.println(score >= 70);
System.out.println(score < 70);
System.out.println(score <= 70);

false
true
false
true

Everyday words map onto the operators, and the boundary decides which one you need:

Now vary the values: a double compared with an int, and negative numbers.

double price = 19.99;
int budget = 20;
System.out.println(price < budget);
int lowToday = -5;
int lowYesterday = -12;
System.out.println(lowToday > lowYesterday);
System.out.println(lowToday <= lowYesterday);

true
true
false

int score = 70;
System.out.println(score => 70);

error: illegal start of expression

double speed = 54.5;
int limit = 55;
System.out.println(speed < limit);
System.out.println(speed >= limit);
int depth = -30;
System.out.println(depth > -20);
System.out.println(limit <= 55);

true
false
false
true

Real questions usually involve a calculation. “Can 14 apples be shared equally among 4 students?” is really “is the remainder of 14 divided by 4 equal to 0?” “Will two shirts at $20.75 cost more than $40?” is “is 20.75 times 2 greater than 40?” So a comparison often has arithmetic on one or both sides.

Recall from Topic 1.3 that Java works out an expression in a fixed order: *, /, and % before + and -. Relational operators come after all of the arithmetic operators. In apples % students == 0, Java first computes apples % students, and only then compares the result with 0. This order makes sense: a comparison needs two finished numbers, so Java finishes each side first. You can add parentheses for readability, as in (apples % students) == 0, but they do not change the answer.

int apples = 14;
int students = 4;
System.out.println(apples % students == 0);
System.out.println(apples / students >= 3);
double total = 12.5 + 8.25;
System.out.println(total * 2 > 40);

false
true
true

The remainder operator is especially useful in comparisons. A whole number is even exactly when dividing it by 2 leaves no remainder, so number % 2 == 0 is a Boolean expression that is true for even numbers and false for odd ones. Here it is with different values, plus a comparison that adds two variables first:

int tickets = 18;
int chairs = 25;
System.out.println(tickets % 2 == 0);
System.out.println(chairs % 2 == 0);
System.out.println(chairs % 2 != 0);
System.out.println(tickets + chairs > 40);

true
false
true
true

18 % 2 is 0, so line 3 is true. 25 % 2 is 1, so line 4 (1 == 0) is false and line 5 (1 != 0) is true: the same remainder, opposite questions. Line 6 adds first, 18 + 25 is 43, then checks 43 > 40.

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

0.30000000000000004
false

double sum = 0.1 + 0.2;
System.out.println(Math.abs(sum - 0.3) < 0.000001);
int cents = 10 + 20;
System.out.println(cents == 30);

true
true

int temperature = 72;
System.out.println(60 < temperature < 80);

error: bad operand types for binary operator '<'
  first type:  boolean
  second type: int

int minutes = 135;
System.out.println(minutes / 60 == 2);
System.out.println(minutes % 60 > 15);
System.out.println(minutes % 2 != 0);
System.out.println(minutes - 35 <= 100);

true
false
true
true

A program often needs the answer to a question more than once, or wants to give it a meaningful name. “Is this person a teenager?” might be needed in several places, and isTeen says more than age >= 13 does each time it appears. Topic 1.4 showed that a variable can hold the result of any expression of its type. A Boolean expression has type boolean, so its result goes in a boolean variable, and a good name for that variable reads like a yes-or-no question or statement: isTeen, passed, canAfford.

There is one thing to understand clearly. When Java runs boolean isTeen = age >= 13;, it evaluates the comparison once, at that moment, and stores the answer, true or false. The variable holds the answer, not the question. If age changes later, isTeen does not change by itself. It changes only if you assign to it again.

int age = 12;
boolean isTeen = age >= 13;
System.out.println(isTeen);
age = 14;
System.out.println(isTeen);
isTeen = age >= 13;
System.out.println(isTeen);

Because a Boolean expression has type boolean, it cannot be stored in a variable of another type. Java checks this before the program runs:

int answer = 5 > 3;
System.out.println(answer);

error: incompatible types: boolean cannot be converted to int

5 > 3 is true, a boolean, and an int variable holds only whole numbers. There is no automatic conversion between boolean and the number types in Java. (Exact wording can vary between Java versions.)

Printing a result with a label uses string concatenation from Topic 1.15: + with a String on one side turns a boolean into the text true or false. But concatenation brings an order-of-operations trap.

int count = 6;
System.out.println("Even: " + count % 2 == 0);

error: bad operand types for binary operator '=='
  first type:  String
  second type: int

int count = 6;
System.out.println("Even: " + (count % 2 == 0));
System.out.println("Remainder: " + count % 2);

Even: true
Remainder: 0

int votes = 26;
int members = 50;
boolean majority = votes * 2 > members;
System.out.println("Majority: " + majority);
System.out.println("Tie: " + (votes * 2 == members));
votes = 25;
System.out.println("Majority: " + majority);
System.out.println("Tie: " + (votes * 2 == members));

Majority: true
Tie: false
Majority: true
Tie: true

int score = 82;
String passed = score >= 70;
System.out.println(passed);

int score = 82;
boolean passed = score >= 70;
System.out.println(passed);

Every comparison so far used primitive values. Programs also need to compare text: does the typed password match the saved one? Does this name come before that one alphabetically? It is natural to reach for == and <. Neither does what you want with a String.

Recall from Topics 1.12 and 1.13 that a variable of a reference type, such as String, does not hold the object itself. It holds a reference to the object, which you can think of as the object’s address in memory. And each use of new creates a brand-new object at a new address.

== always compares what is stored in the two variables. For an int, that is the number. For a String variable, that is the reference. So for reference types, first == second asks “do these two variables refer to the very same object?” It does not look inside the objects at all. Two different objects can hold exactly the same characters, the way two copies of the same book are still two books.

To ask whether two strings hold the same text, use equals from Topic 1.15.

String first = new String("Tiger42");
String second = new String("Tiger42");
System.out.println(first.equals(second));
System.out.println(first == second);
System.out.println(first != second);

first  ──►  [ "Tiger42" ]   object 1
second ──►  [ "Tiger42" ]   object 2

true
false
true

The size operators <, >, <=, and >= do not work on strings at all. To ask which string comes first alphabetically, use compareTo from Topic 1.15, which returns an int, and then compare that int with 0 using a relational operator. That turns compareTo into a yes-or-no question.

String a = "apple";
String b = "banana";
System.out.println(a.compareTo(b) < 0);
System.out.println(a.compareTo(b) == 0);
System.out.println(b.compareTo(a) > 0);
System.out.println(a.length() < b.length());

true
false
true
true

String a = "apple";
String b = "banana";
System.out.println(a < b);

error: bad operand types for binary operator '<'
  first type:  String
  second type: String

String saved = new String("ok");
String typed = new String("ok");
System.out.println(saved == typed);
System.out.println(saved.equals(typed));

String first = "Lopez";
String second = "Lee";
System.out.println(first.compareTo(second) < 0);
System.out.println(second.compareTo(first) < 0);
System.out.println(first.equals("lopez"));
System.out.println(first.length() > second.length());

false
true
false
true

A theater’s ticket kiosk answers several yes-or-no questions about a customer before selling a ticket. This program uses every idea in the chapter. Try predicting all six lines before reading the trace.

public class TicketCheck
{
    public static void main(String[] args)
    {
        int age = 15;
        double cash = 12.0;
        double ticketPrice = 11.5;
        int seatsLeft = 40;
        int groupSize = 6;
        String rating = new String("PG-13");
        boolean oldEnough = age >= 13;
        boolean canAfford = cash >= ticketPrice;
        System.out.println("Old enough: " + oldEnough);
        System.out.println("Can afford: " + canAfford);
        System.out.println("Exact cash: " + (cash == ticketPrice));
        System.out.println("Room for group: " + (seatsLeft - groupSize >= 0));
        System.out.println("Even group: " + (groupSize % 2 == 0));
        System.out.println("Rated PG-13: " + rating.equals("PG-13"));
    }
}

Old enough: true
Can afford: true
Exact cash: false
Room for group: true
Even group: true
Rated PG-13: true

• A relational operator compares two values and produces a boolean, so any expression built with one is a Boolean expression whose value is true or false.
• == asks whether two values are the same and != whether they differ. For primitive types these compare the actual values, which is why double round-off error can make == give false.
• <, >, <=, and >= compare numbers. Only the “or equal” versions are true when the two values are the same, so the boundary decides which operator a question needs.
• Arithmetic happens before comparison, and + happens before comparison too, so a comparison inside a printed label needs parentheses.
• A Boolean result can be stored in a boolean variable; it holds the answer at that moment and does not update on its own.
• For reference types, == and != compare references, not contents. Compare string text with equals, and alphabetical order with compareTo and 0.

import java.util.Scanner;

public class GymEntry
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("17 9.5 Gold");
        int age = input.nextInt();
        double balance = input.nextDouble();
        String level = input.next();
        double fee = 10.0;
        boolean adult = age >= 18;
        System.out.println("Adult: " + adult);
        System.out.println("Short: " + (fee - balance));
        System.out.println("Enough money: " + (balance >= fee));
        System.out.println("Gold member: " + level.equals("Gold"));
        System.out.println("Odd age: " + (age % 2 == 1));
    }
}

Adult: false
Short: 0.5
Enough money: false
Gold member: true
Odd age: true

import java.util.Scanner;

public class TeamWrong
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("blue blue");
        String myTeam = input.next();
        String yourTeam = input.next();
        System.out.println("Same team: " + (myTeam == yourTeam));
    }
}

import java.util.Scanner;

public class TeamFixed
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("blue blue");
        String myTeam = input.next();
        String yourTeam = input.next();
        System.out.println("Same team: " + myTeam.equals(yourTeam));
    }
}

String x = "Zoo";
String y = "apple";
System.out.println(x.compareTo(y) < 0);
System.out.println(x.equals("zoo"));
System.out.println(x.length() == y.length());
System.out.println(y.compareTo(x) < 0);

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can predict the result of == and != and explain why = cannot be used to compare. Reread
• I can choose between <, >, <=, and >= for a question, paying attention to the boundary value. Reread
• I can work out a comparison that contains arithmetic, and explain why == on double results is risky. Reread
• I can store a Boolean result in a boolean variable and print it with a label, using parentheses where needed. Reread
• I can explain what == does with two String objects and use equals and compareTo instead. Reread