Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 2.10 Relational Expressions

Relational expressions include the familiar greater-than (>), less-than (<) and equal-to (==) operators. Note that testing for equality in Java is accomplished using the double-equal operator (==). The single-equal operator (=) is reserved for assignment.
In addition to these operators, Java implements compound relational operators, including greater-than or equal-to (>=), less-than or equal-to (<=) and not-equal-to (!=). These have the familiar interpretations.
Table 2.10.1. Type Promotion
Operator Type Description
< binary, infix less-than
<= binary, infix less-than or equal-to
> binary, infix greater-than
>= binary, infix greater-than or equal-to
== binary, infix equal-to
!= binary, infix not equal-to
All relational operators evaluate to a boolean value (true or false). If you think about that for a moment, you should see the logic in that statement. In general, relational operators involving > or < take numerical operands.
Relational operators may be used in larger expressions that also involve arithmetic and even assignment operators. All relational operators have a precedence that is lower than arithmetic operators. When evaluating expressions that mix both, evaluate the arithmetic subexpressions first, and then the relational expression. Consider the following examples.
jshell> int a = 1, b = 2, c = 3;
a ==> 1
|  created variable a : int
b ==> 2
|  created variable b : int
c ==> 3
|  created variable c : int

jshell> a < b;
$4 ==> true
|  created scratch variable $4 : boolean

jshell> a > b;
$5 ==> false
|  created scratch variable $5 : boolean

jshell> a + b < c;
$6 ==> false
|  created scratch variable $6 : boolean

jshell> a + b == c;
$7 ==> true
|  created scratch variable $7 : boolean

jshell> a + b <= c;
$8 ==> true
|  created scratch variable $8 : boolean

jshell> c > a;
$9 ==> true
|  created scratch variable $9 : boolean

jshell> c >= a;
$10 ==> true
|  created scratch variable $10 : boolean

jshell> c != a + b;
$11 ==> false
|  created scratch variable $11 : boolean

jshell> a < b < c;
|  Error:
|  bad operand types for binary operator '<'
|    first type:  boolean
|    second type: int
|  a < b < c;
|  ^-------^

jshell>
Note how that last example in the above results in a "bad operand type" error. The syntax a < b < c is common mathematics notation, but it is invalid Java. When evaluating this expression, the left-most operator is evaluated first to the boolean value of true. That is, a < b becomes true. Then the right-most operator is evaluated as true < c. The < operator cannot take a boolean value type as an operand, therefore the expression results in an error.
Consider one more example.
jshell> 0.1 + 0.2 == 0.3;
$12 ==> false
|  created scratch variable $12 : boolean

jshell>
Clearly, we know that \(0.1 + 0.2\) is exactly equal to \(0.3\text{.}\) Why does Java evaluate this expression to false? Is Java broken?
It turns out that the problem is not with Java, but with floating point number representation in general. The explanation becomes obvious by observing the result of 0.1 + 0.2.
jshell> 0.1 + 0.2;
$13 ==> 0.30000000000000004
|  created scratch variable $13 : double

jshell>
The answer is not the expected value of 0.3, but instead it has an extra "4" way out in the last decimal place. The fundamental reason for this is that the numbers 0.1, 0.2, and 0.3 cannot be represented exactly in the underlying representation of a double-precision number. Recall from Section 1.2 that computer memory stores numeric values in binary (base 2 numbers), not base 10. While integer values may be represented exactly in binary, certain fractional floating-point numbers are not.
The nearest binary-encoded floating-point number to the value 0.3, out to 55 decimal places, is
0.299999999999999988897769753748434595763683319091796875.
By contrast, without considering all the technical detail associated with the rounding and approximation required, the sum 0.1 + 0.2 evaluates to the value
0.3000000000000000444089209850062616169452667236328125
a different number. This helps explain why 0.1 + 0.2 == 0.3 evaluates to false, and teaches us an important lesson about comparing floating-point numbers.

Best Practice: Never compare floating-point numbers with ==.

Always compare floating-point numbers as being "close-enough" by testing that the absolute value of their difference is less than some very small number.
See the following example for the better way to test if 0.1 + 0.2 is "close enough" to 0.3.
jshell> Math.abs((0.1 + 0.2) - 0.3) < 0.000000000000001;
$1 ==> true
|  created scratch variable $1 : boolean

jshell>

Activity 2.10.1.

I exercised 64 minutes the day before yesterday, 51 minutes yesterday, and 42 minutes today. Write two expressions. One that tells me how many hours I’ve exercised, and a second that tells me how many minutes of the last hour that I have completed so far.
Answer.
jshell> (64 + 51 + 42) / 60 + " hours"
$2 ==> "2 hours"
|  created scratch variable $2 : String

jshell> (64 + 51 + 42) % 60 + " minutes"
$3 ==> "23 minutes"
|  created scratch variable $3 : String

Activity 2.10.2.

I ordered three doughnuts at $2.55 each and a cup of coffee for $3.10. I have a $10 dollar bill. Write an expression that tells me if I can afford my order or I should change my order to two doughnuts.
Answer.
jshell> 3*2.55 + 3.10 < 10
$7 ==> false
|  created scratch variable $7 : boolean

jshell> 2*2.55 + 3.10 < 10
$8 ==> true
|  created scratch variable $8 : boolean

Activity 2.10.3.

Start with the following declarations.
double xc = 0.5, yc = 0.5, r = 0.3, x = 0.6, y = 0.7;
Write one or more Java expressions that test if the distance between the points \((x, y)\) and \((x_c, y_c)\) is less than \(r\text{.}\) Recall the distance formula \(distance = \sqrt{(x - x_c)^2 + (y - y_c)^2}\text{.}\)
If \((x_c, y_c)\) is the center of a circle with radius \(r\text{,}\) then your computation will test if the point \((x, y)\) is within the circle.
Answer.
jshell> double xc = 0.5, yc = 0.5, r = 0.3, x = 0.6, y = 0.7;
xc ==> 0.5
|  created variable xc : double
yc ==> 0.5
|  created variable yc : double
r ==> 0.3
|  created variable r : double
x ==> 0.6
|  created variable x : double
y ==> 0.7
|  created variable y : double
jshell> Math.sqrt( Math.pow(x-xc,2) + Math.pow(y-yc,2)) < r
$14 ==> true
|  created scratch variable $14 : boolean
<Prev^TopNext>