Precedence is the order in which the evaluation of the operators in an expression is performed. There are a handful of operators in Java, each having precedence. In case the operators have the same precedence, then associativity is taken into consideration as the tiebreaker for further evaluation.

## Precedence of Operators

Having understood how we can tackle solving an expression with the precedence of operators that decides the order of execution. In this section of this article on Java Operator Precedence, let us look at how the operators fare in the table given below:

Rank | Operator | Description | |
---|---|---|---|

1 | () | Parentheses (grouping) | |

2 | [] | Array access and member access | |

3 | ++ — | Postfix increment/decrement | |

4 | ++ — + – ! ~ | Prefix increment/decrement, unary plus/minus, logical negation/complement | |

5 | * / % | Multiplication, division, and remainder | |

6 | + – | Addition and subtraction | |

7 | << >> >>> | Bitwise shift operators | |

8 | < <= > >= | Relational operators | |

9 | \== != | Equality operators | |

10 | & | Bitwise AND | |

11 | ^ | Bitwise exclusive OR | |

12 | I | Bitwise inclusive OR | |

13 | && | Conditional AND | |

14 | II | Conditional OR | |

15 | ?: | Ternary conditional | |

16 | \= += -= *= /= %= &= ^= | = <<= >>= >>>= | Assignment operators |

In the above table, lower rank indicates higher precedence, as parenthesis having a rank of first will be first in the order of execution.

As we discussed Operators with higher precedence are evaluated before operators with lower precedence. For example, in the expression a + d * c, the multiplication operator (*) has higher precedence than the addition operator (+), so the multiplication is performed first.

## Handling Same Precedence with Associativity

In case there are operators sharing the same rank then the tiebreaker is performed by taking associativity into consideration which is either left to right or right to left.

The evaluation of operators from left to right is known as left-to-right associativity. For instance, in the expression a – b – c, the subtraction operators are evaluated from left to right, resulting in (a – b) – c.

On the other hand, right-to-left associativity pertains to the evaluation of operators from right to left. An example of this is the assignment operator =, which has right-to-left associativity. Thus, in the expression a = b = c, the assignment is executed from right to left, and the expression is equivalent to a = (b = c).

Associativity | Operators | ||
---|---|---|---|

Left-to-right | + – * / % << >> >>> < <= > >= instanceof | ||

Left-to-right | \== != & ^ | && | |

Right-to-left | \= += -= *= /= %= &= ^= | = <<= >>= >>>= | |

Right-to-left | ? : ++ — + – ! ~ (type) new [] . |

The above table can be essential in determining the output in similar java operator precedence. So with the combination of associativity and precedence, it becomes easy for us to understand how expressions are evaluated in java.

## Impact of Parenthesis on Precedence

In certain scenarios, it may be necessary to alter the default operator precedence and prioritize the evaluation of a specific expression. One way to achieve this is by utilizing parentheses.

Expressions enclosed in parentheses are evaluated before any other expressions, regardless of their default precedence. For instance, consider the expression (a + b) * c. Although multiplication has a higher precedence, the addition operation is executed first because it is enclosed in parentheses.

The order of evaluation in terms of Java Operator Precedence can be altered with the use of parenthesis no matter what the operator precedence is. It can be understood with the help of the following example:-

`int result = (13 + 5) * 1 - 3 / 1;`

In this expression, the addition is evaluated first because of the parentheses, resulting in 18 * 1 – 3, which evaluates to 15.

## Understanding Operator Precedence in Java

Now that we have an idea of what Java Operator Precedence stands for. Let us take an example to understand how the Java Operator Precedence works in an expression.

Suppose we have an expression,

`int result = 13 + 5 * 1 - 3 / 1;`

In this expression, the operators are evaluated in the following order: For the first step, 5 * 1 is evaluated first because multiplication has higher precedence than addition and subtraction.

In the second step, 3 / 1 is evaluated next because division has higher precedence than addition and subtraction.

The results of the first and second steps are then used to perform the addition and subtraction in left-to-right order. So 13 + 5 – 3 is evaluated to give a final result of 15.

## Example of Operator Precedence in Java:

Suppose we have the expression 5 * 3 + 10 / 2 – 4, and we want to evaluate it according to operator precedence and associativity rules in Java.

First, we need to identify the operators and their precedence:

```
Precedence Operators
1 * / %
2 + -
```

Based on the table, we can see that the multiplication operator (*) has higher precedence than the addition operator (+), so we evaluate 5 * 3 first:

```
5 * 3 + 10 / 2 - 4
15 + 10 / 2 - 4
```

Next, we need to evaluate the division operator (/), which has the same precedence as the multiplication operator (*), but left-to-right associativity:

```
15 + 10 / 2 - 4
15 + 5 - 4
```

Finally, we evaluate the addition operator (+) and the subtraction operator (-), which have the same precedence as each other, but left-to-right associativity:

```
15 + 5 - 4
16
```

Therefore, the value of the expression 5 * 3 + 10 / 2 – 4 is 16.

**Conclusion**

In this article, we understood what java operator precedence is and understood how expressions are evaluated in java under the hood. We studied precedence and associativity tables and performed examples as well as understood how parenthesis can alter the execution of an expression.

We hope you liked this article on Java Operator Precedence and expect to see you with another informative article.

## Frequently Asked Questions

**1. What is operator precedence in Java?**

Operator precedence is a set of rules that dictate the order in which operators in an expression are evaluated. It determines which operation is performed first and which one is performed last.

**2. Why is it important to understand operator precedence in Java?**

Understanding operator precedence is crucial in writing correct and efficient code. By knowing the order in which operators are evaluated, you can avoid common errors and ensure that your code behaves as intended.

**3. Can operator precedence be changed in Java?**

No, the precedence of operators in Java is fixed and cannot be changed. However, you can use parentheses to override the default precedence and force a certain expression to be evaluated first.

**4. How can I remember the order of operator precedence in Java?**

A common way to remember the order of operator precedence in Java is to use the acronym PEMDAS, which stands for Parentheses, Exponents, Multiplication and Division, and Addition and Subtraction. Operators with the same precedence are evaluated from left to right, with the exception of the assignment operator, which has right-to-left associativity. It’s also helpful to refer to a table of operator precedence when writing expressions with multiple operators.