 # Java Operators: Performing Operations on Primitive Data Types

• Print
This chapter is from the book

## Operator Precedence

There are all these operators and the good news is that they can all be used together. Consider multiplying a value by 10 and adding 5 to it:

`int result = a * 10 + 5;`

But what happens when you want to add 5 to a value, and then multiply it by 10? Does the following work?

`int result = a + 5 * 10;`

Consider for a moment that in the compiler it performs its calculations left to right, now how would you add 5 multiplied by 10 to a?

`int result = 5 * 10 + a;`

This is starting to get confusing and complicated! Furthermore it is not intuitive! When you study mathematics, you learn that certain operations are reflective, meaning that they can be performed in any order and offer the same result. Thus, the following two statements are equivalent:

```int result = a + 5 * 10;
int result = 5 * 10 + a;```

The confusion between these two statements is what operation to perform first; the multiplication or the division? How would you solve this in your math classes? You would simply instrument the statements with parentheses to eliminate the confusion:

```int result = ( a + 5 ) * 10;
int result = ( 5 * 10 ) + a;```

These statements are now read as follows: add 5 to a, and then multiply the result by 10; and multiply 5 by 10, and then add a to the result, respectively. In mathematics, the operation enclosed in parentheses is completed before any other operation.

The same mechanism can be implemented in Java, and it is! To qualify what operations to perform first, you can eliminate all ambiguity by explicitly using parentheses to denote what operations are grouped together. But that does not solve the problem of how to handle a statement without parentheses. What is the result of the following operation?

`int result = 8 + 5 * 10;`

Is the result 130 or 58?

The answer is that there needs to be a set of rules that defines the order of operation execution. This is defined by what is called the operator precedence. The operator precedence defines what operators take precedence over other operators, and hence get executed first. All programming languages define an operator precedence, which is very similar between programming languages, and you must be familiar with it.

### Java Operator Precedence

Table 3.10 defines the operator precedence for Java. Precedence is determined by reading Table 3.10 from top to bottom, left to right.

#### Table 3.10 Operator Precedence

 Type Operators Unary ! ~ ++ -- + - () new Arithmetic * / % + - Shift << >> >>> Comparison < <= > >= instanceof == != Bitwise & ^ | Short-circuit && || Ternary ?: Assignment = "op=" (for example, *=, +=, %=, ^=)

Unary operators are those operators that operate on a single variable, such as increment and decrement (++), positive and negative signs (+ –), the bit-wise NOT operator (~), the logical NOT operator (!), parentheses, and the new operator (to be discussed later).

Arithmetic operators are those operators used in mathematical operations. Here it is important to note that this table is read from left to right, therefore multiplication and division have greater precedence than addition and subtraction. Thus the answer to the aforementioned question:

`int result = 8 + 5 * 10;`

The result is 58; multiplication has a higher precedence than addition, so the multiplication is performed first followed by the addition. So, the compiler reads this as multiply 5 by 10 (50) and add 8 to the result (50 + 8 = 58).

Shift operators refer to the bit-wise shift left, shift right, and shift right and fill with zeros operators.

The logical comparison operators follow with the familiar greater than, less than, and equality variations. Comparison operators return a boolean value, so there is one additional operator added: instanceof; this operator will be addressed later when you have a little more Java under your belt.

Next are the bitwise AND, OR, and XOR operators followed by the logical AND and OR (&& ||), referred to as the short-circuit operators.

Next is a new category of operators in the ternary operators; the sole operator in this category is referred to as ternary because it uses three operands when computing its result. It is the following form:

`a ? b : c;`

This statement is read as follows: If a is true, then the result of this operation is b, otherwise the result is c. The ternary operator does not have to be comprised of single values, the only requirement is that the first value or operation resolves to be a boolean. Consider the following examples:

```int result = ( 5 > 3 ) ? 2 : 1; // result is 2
int result = ( 5 < 3 ) ? 2 : 1; // result is 1```

In the first example 5 is greater than 3, therefore the result is 2; in the second example 5 is not less than 3, so the result is 1. So more clearly written, the form of the ternary operator is

`(boolean expression) ? (return if true) : (return if false)`

The ternary operator is rarely used, and is mainly inherited from Java's initial syntactical base from C/C++. It is a somewhat cryptic shortcut, but is perfectly legal, so be sure to understand how it is used.

The final sets of operators in the operator precedence hierarchy are the assignment operators. The assignment operators include the familiar assignment (=) operator as well as a set of additional assignment operators referred to generically as op= (operator equal). These new operators are shortcut operators used when performing an operation on a variable and assigning the result back to that variable. Consider adding 5 to the variable a; this could be accomplished traditionally as follows:

`a = a + 5;`

Because this is such a common operation Java provides a shortcut for it:

`a += 5;`

This is read: a plus equal 5, or explicitly a equals a plus 5. The operator equal operator can be applied to all the arithmetic, shift, and bit-wise operators.

Finally, whenever there is ambiguity or you desire a higher degree of readability, you can use parentheses to explicitly qualify the operator precedence yourself.