Boolean Data and Operators

Section 5.2 Boolean Data and Operators

As we learned in Chapter 1, the boolean type is one of Java’s primitive types. For this type, there are only two possible values, true and false.

The boolean type is derived from the work of British mathematician George Boole, who in the 1850s, developed an algebra to process logical expressions such as p and q. Such boolean expressions produce a value that is either true or false. Every modern programming language provides some means of representing boolean expressions.

The boolean type has several important uses. As we saw in Chapter 1, expressions of the form num == 7 and 5 < 7 have boolean values. Similarly, as we saw in Chapter 3, the boolean type is also used to represent the condition in the if statement:

if (boolean expression)
   statement

For this reason, boolean expressions are also called conditions. Along these same lines, a boolean variable can be used as a flag or a signal to “remember” whether or not a certain condition holds. For example, in the following code fragment, we use isDone to mark when a particular process is completed:

boolean isDone = false; // Initialize the flag
...                     // Do some processing task
isDone = true;          // Set flag when the task done
...                     // Do some other stuff
if (isDone)             // Check if finished the task
...                     //  If so, do something
else
...                     //  Or, do something else

Subsection 5.2.1 Boolean (or Logical) Operations

Like all the other simple data types, the boolean type consists of certain data— the values true and false — and certain actions or operations that can be performed on those data. There are four basic boolean operations:

AND (signified by &&),
OR (signified by \(\mid\mid\)),
EXCLUSIVE-OR (signified by \(\wedge\)),
and NOT (signified by !).

These are defined in the truth table shown in Table 5.2.1.

Activity 5.2.1.

Try running the code below to see the boolean operator or (||) in action. Change the values of the two boolean variables to figure when the or-expression is true.

A truth table defines boolean operators by giving their values in all possible situations. The first two columns of the table give possible boolean values for two operands,o1 and o2. An operand is a value used in an operation. Note that each row gives a different value assignment to the two operands, so that all possible assignments are represented. The remaining columns give the values that result for the various operators given the assignment of values to o1 and o2.

Table 5.2.1. Truth-table definitions of the boolean operators: AND (&&), OR (\(\mid\mid\)), EXCLUSIVE-OR (\(\wedge\)), and NOT (!).

OP 1	OP 2	AND	OR	XOR	not
o1	o2	o1 && o2	o1 \|\| o2	o1 \(\wedge\) o2	!o1
`true`	`true`	`true`	`true`	`false`	`false`
`true`	`false`	`false`	`true`	`true`	`false`
`false`	`true`	`false`	`true`	`true`	`true`
`false`	`false`	`false`	`false`	`false`	`true`

To see how to read this table, let’s look at the AND operation, which is defined in column 3. The AND operator is a binary operator — that is, it requires two operands, o1 and o2. If both o1 and o2 are true, then (o1 && o2) is true (row1). If either o1 or o2 or both o1 and o2 are false, then the expression (o1 && o2) is false (rows 2, 3 and 4). So, the only case in which (o1 && o2) is true is when both o1 and o2 are true (row 1).

The boolean OR operation (column 4) is also a binary operation. If both o1 and o2 are false, then \((o1 \mid\mid o2)\) is false (row 4). If either o1 or o2 or both o1 and o2 are true, then the expression \((o1 \mid\mid o2)\) is true (rows 1-3). So, the only case in which \((o1 \mid\mid o2)\) is false is when both o1 and o2 are false.

The boolean EXCLUSIVE-OR (XOR) operation (column 5) is a binary operation, which differs from the OR operator in that it is true when either o1 or o2 is true (rows 2 and 3), but it is false when both o1 and o2 are true (row 1).

The NOT operation (column 6) is a unary operator — it takes only one operand— and it simply reverses the truth value of its operand. Thus, if o1 is true, !o1 is false, and vice versa.

Exercises Self-Study Exercises

Evaluate the following boolean expressions and figure out whether they are true or false.

1. && Operator.

(3 < 5) && (5 > 1)

true
Both sides of the And operator are true.
false
Both sides of the And operator are true.

2. || Operator.

(3 > 5) || (5 > 1)

true
One side of the Or operator is true, so the whole expression is true.
false
One side of the Or operator is true, so the whole expression is true.

3. ! Operator.

!(3 < 5)

true
Since 3 is less than 5, the negation of that is false.
false
Since 3 is less than 5, the negation of that is false.

Subsection 5.2.2 Precedence and Associativity

In order to evaluate complex boolean expressions, it is necessary to understand the order in which boolean operations are carried out by the computer. For example, what is the value of the following expression?

true || true && false

The value of this expression depends on whether we evaluate the \(\mid\mid\) first or the && first. If we evaluate the \(\mid\mid\) first, the expression’s value will be false; if we evaluate the && first, the expression’s value will be true. In the following example, we use parentheses to force one operation to be done before the other:

EXPRESSION                EVALUATION
----------                ----------
( true || true )  &&  false ==> true  &&  false ==> false
true || ( true  &&  false ) ==> true || false ==> true

As these evaluations show, we can use parentheses to force one operator or the other to be evaluated first. However, in Java, the && operator has higher precedence than the \(\mid\mid\) operator. Therefore, the second alternative corresponds to the default interpretation that Java would apply to the expression that has no parentheses. In other words, given the expression true || true && false, the AND operation would be evaluated before the OR operation even though the OR operator occurs first (i.e., to the left) in the unparenthesized expression.

Table 5.2.2. Precedence order of the boolean operators

Precedence Order	Operator	Operation
1	`( )`	Parentheses
2	`!`	NOT
3	`^`	EXCLUSIVE-OR
4	`&&`	AND
5	`\|\|`	OR

As this example illustrates, the boolean operators have a built-in precedence order which is used to determine how boolean expressions are to be evaluated. The precedence rules are set out in Table 5.2.2.

A simple method for evaluating an expression is to parenthesize the expression and then evaluate it. For example, to evaluate the complex expression

true || !false ^ false && true

we would first parenthesize it according to the rules in Table 5.2.2, which gives the following expression:

true || (((!false) ^ false) && true)

We can then evaluate this fully parenthesized expression, step by step, starting at the innermost parentheses:

Step 1. true || ((true ^ false) && true)
Step 2. true || (true && true)
Step 3. true || true
Step 4. true

Principle 5.2.3. PROGRAMMING TIP: Parentheses.

Parentheses can (and should) be used to clarify any expression that appears ambiguous or to override Java’s default precedence rules.

In addition to operator precedence, it is necessary to know about an operator’s associativity in order to evaluate boolean expressions of the form (op1 || op2 || op3). Should this expression be evaluated as ((op1 || op2) || op3) or as (op1 || (op2 || op3))}?

The binary boolean operators all associate from left to right. Thus, the expressions

true ^ true ^ true   // Same as: (true ^ true) ^ true
true && true && true // Same as: (true && true) && true
true || true || true // Same as: (true || true) || true

would be evaluated as follows:

EXPRESSION               EVALUATION
----------------         -----------------
(true ^ true)  ^ true    ==> false ^ true  ==> true
(true && true)  && true  ==> true  && true ==> true
(true || true)  || true  ==> true  || true ==> true

Subsection 5.2.3 Short-Circuit Evaluation

Another important feature of the boolean operators is that they utilize a form of evaluation known as short-circuit evaluation, in which a boolean expression is evaluated from left to right, and the evaluation is discontinued as soon as the expression’s value can be determined, regardless of whether it contains additional operators and operands. For example, in the expression

expr1 && expr2

if expr1 is false, then the AND expression must be false, so expr2 need not evaluated. Similarly, in the expression

expr1 || expr2

if expr1 is true, then the OR expression must be true, so expr2 need not evaluated.

In addition to being a more efficient form of evaluating boolean expressions, short-circuit evaluation has some practical uses. For example, we can use short-circuit evaluation to guard against null pointer exceptions. Recall from Chapter 2 that a null pointer exception results when you try to use an uninstantiated reference variable — that is, a reference variable that has not been assigned an object. For example, if we declare a OneRowNim variable without instantiating it and then try to use it, a null pointer exception will result:

OneRowNim game;        // Uninstantiated Reference
if (!game.gameOver())  // Null pointer exception
    game.takeSticks(num);

In this code, a null pointer exception results when we use game in the method call game.gameOver(). We can use short-circuit evaluation to prevent the exception from occurring:

if ((game != null) && (!game.gameOver())
    game.takeSticks(num);

In this case, because game != null is false, neither method call involving game is made, thus avoiding the exception.

Exercises Self-Study Exercises

Suppose the following variable declarations are made:

boolean A = true, B = true, C = true;
boolean X = false, Y = false, Z = false;

Given these declarations, evaluate each of the following expressions (don’t forget to take operator precedence and associativity into account):

1. Expression 1.

A || B && C

true
(A=true or B=true) and C=true.
false
(A=true or B=true) and C=true.

2. Expression 2.

A ^ B && C

true
(A=true xor B=true) and C=true.
false
(A=true xor B=true) and C=true.

3. Expression 3.

(!X ^ A) && (B ^ !Y)

true
(!X = true xor A=true)=false and (b=true xor !Y=true)=false.
false
(!X = true xor A=true)=false and (b=true xor !Y=true)=false.

You have attempted of activities on this page.

Prev Top Next