BHSawesome AP CSA

In Subsection 2.3.1 Basic arithmetic we learned about arithmetic operators like + and * that operate on numeric values to produce other numeric values. Now we need to learn about comparison operators that operate on numbers but produce boolean values. Comparison operators can be further divided into four relational operators that test ordering relationships between numbers and two equality operators which simply check whether two numbers are the same or different.

The four relational operators (<, >, <=, >=) should be familiar from math class. Note however that due to the limitations of character sets traditionally used in programming languages, we write <= rather than ≤ and >= instead of ≥. To remember the correct order of the two characters in <= and >=, just write them in the same order you would say them in English: “less than or equal to” not “equal to or less than”.

If you need a refresher on these operators, one way to remember which is which is the hungry alligator mnemonic beloved by elementary school teachers—think of < and > as the mouths of hungry alligators who always want to eat the bigger number; a < or > expression is only true if the open mouth of the alligator is about to chomp the bigger number. (With <= and >= the alligator is also okay if the number it’s going to eat is the same as the other number.)

The two equality operators (== and !=) are relatively straightforward. A couple things to note however, one is that they are both written with two characters. In particular the equality operator == is different than the assignment operator =. So if a and b are int values, a == b is a boolean expression, i.e. it’s value will be either true or false. But a = b is an int expression whose value will be the original value of b and will also have the side effect of assigning that value to a.

Unlike the relational operators, the equality operators can be used with any kinds of values, int, double, boolean as well as reference types like String and other types we’ll learn about later. But there are some subtleties to how they work with different kinds of values.

For int and boolean values, == and != are quite straightforward. Either two int values are the same or they are not. However, we will rarely use these operators with boolean values as doing so is usually unecessary and lead to a common mistake which we’ll discuss in Section 4.5 if statement traps and pitfalls.

For String and other reference types we’ll discuss later, they “work” but maybe not in the way you’d expect. We’ll discuss that in detail in Subsection 9.2.2 Comparing Objects.

And finally, the equality operators should almost never be used with double values. They do work in the sense that if two double values are exactly the same, they will be ==. The problem is that because computers perform double math with limited precision, sometimes expressions that seem like they should produce mathematically equivalent results don’t produce exactly the same double values so even though they should be equal according to math they won’t be according to ==. One of the simplest examples is:

0.1 + 0.2 == 0.3 // evaluates to false!

You might wonder why these are different if double values can store up to 15 decimal places of precision! Understanding exactly why would involve getting into quite a lot of details about how double values are represented in memory that are well beyond the AP curriculum. But suffice it to say that this is a fact about how modern computers work, not a bug in Java. As a practical matter when doing double math, instead of comparing values for exact equality we should check whether the difference between two values is less than some meaningful threshold. For instance, if we were performing some computation on measurements in meters and wanted to check that the answer we got was “the same” as some expected value, we might use an expression like the following to check that they are the same to a tenth of a millimeter:

Math.abs(computedMeters - expectedMeters) < 0.0001

A thing that comes up often enough in both real world coding and on the AP exam to be worth calling out is how to use the equality operators in combination with the remainder operator (%) to test whether int values are evenly divisible by other int values.

If a is evenly divisible by b, that just means that the remainder if you divide a by b is zero. So to check if a is evenly divisible by b (or is a multiple of b, which is another way to say the same thing) we can just write a % b == 0.

Problems requiring use of % come up frequently on the AP exam. Keep it in mind for the following uses:

Another common way to want to produce boolean values is at random with some probability. This is quite easy since Math.random(), which we first saw in Section 3.3 The Math class, returns a random number between 0.0 and 1.0 which is exactly how probabilities are usually expressed. (Zero probability means something definitely won’t happen; probability one means it definitely will.)

So we use Math.random() in combination with the < operator to write an expression that will be true with a given probability. For example, to simulate a coin flip, we can use the expression Math.random() < 0.5 which will be true with probability 0.5 or 50% of the time.

if (Math.random() < 0.5) {
    System.out.println("Heads");
} else {
    System.out.println("Tails");
}

More generally, for any probability p between zero and one, Math.random() < p will be true with that probability.

if (Math.random() < p) {
    System.out.println("Event happened");
} else {
    System.out.println("Event did not happen");
}

The easy way to remember that it should be < and not > or <= is to remember that Math.random() returns a number greater than or equal to 0.0 and less than 1.0. So Math.random() < 0.0 is never true Math.random() < 1.0 always is.

The other set of operators in Java that produce boolean values are the logical operators. These operate on boolean values to produce new boolean values just like the arithmetic operators operate on numeric values and produce numeric values.

The three logical operators in Java come from Boolean algebra, a system for evaluating logical statements invented by George Boole, a 19th century English mathematician most famous for his book The Laws of Thought. These days we call these three operatarors logical and, logical or and logical not. And you are almost certainly already completely familiar with these operators and how they work even if you’ve never heard of George Boole.

For example, if you were looking for someone to share some chocolate ice cream with, you’d know that you need to find someone who likes ice cream and who also likes chocolate. A friend who likes ice cream but doesn’t like chocolate wouldn’t be interested. And another friend who likes chocolate but hates ice cream would also not be interested. If you understand that, you understand the logic of the situation which is expressed with logical and.

A logical and combines two statements like “likes ice cream” and “likes chocolate”, each of which is either true or false, into a new statement “likes ice cream and likes chocolate” that is only true if both of the sub-statements are true.

In Java the logical and operator is written &&. Thus if we have two boolean expressions, such as two variables likesIceCream and likesChocolate, we can write an expression that combines them with &&:

likesIceCream && likesChocolate // true if, and only if, both variables are true

You already understand logical or if you understand that if need to get something off a high shelf that you can’t reach, you either need a tall friend or a step stool. You don’t need both a tall friend and a step stool—one or the other is fine. (Though if you did have both that would also work.) In Java we write logical or as ||:

haveTallFriend || haveStepStool // true if either, or both, variables are true

The final logical operator, logical not covers the logic of, “You can go out if you’re not grounded”. If the statement “you’re grounded” is true, then you can’t go out. But if the statement is false, then you can. In other words, logical not just flips the meaning of the statement, true to false and false to true. Logical not is written ! in Java and goes before the expression it operates on:

!grounded // true if grounded is false, false otherwise

You can say that !grounded is the logical negation of grounded, similar to how \(-4\) is the negation of \(4\text{.}\)

Just like we can use the == and % operators together to test whether numbers are divisible by other numbers, we can combine relational and logical operators to test whether a number is in a certain range.

In math we can write \(0 \le x \lt 100\) to express that \(x\) is in the range from zero (inclusive) to one hundred (exclusive). Unfortunately if we translate that directly to Java as 0 <= x < 100 we will get a compiler error. This is because 0 <= x produces a boolean which can’t then be an operand to the < operator. Instead we need to use && to combine two boolean expressions:

0 <= x && x < 100 // True if x is in range from 0 to 100, exclusive.

Less frequently we may want to write an expression that is true if a variable is not in a particular range. That’s as easy as applying a ! to the whole range expression. We need to put the range expression in parentheses because ! has very high precedence.

!(0 <= x && x < 100) // True if x is outside the range from 0 to 100, exclusive.

We could also write that in this logically equivalent way:

x < 0 || x >= 100

Both && and || use short circuit evaluation. That means that the second expression (on the right of the operator) isn’t necessarily checked, if the result from the first expression is enough to tell if the compound boolean expression is true or false:

if (x > 0 && (y / x) == 3)
{
   System.out.println("first case");
}
else
{
   System.out.println("second case");
}

if (x == 0 || (y / x) == 3)
{
   System.out.println("first case");
}
else
{
   System.out.println("second case");
}