Operator precedence determines the order in which the operators in an expression are evaluated.

Before you start reading this article, you should have a basic knowledge of Java Operators.

Now, take a look at the statement below:

int myInt = 12 - 4 * 2;

What will be the value of `myInt`? Will it be `(12 - 4)*2`

, that is, `16`

? Or it will be `12 - (4 * 2)`

, that is, `4`

?

When two operators share a common operand, `4`

in this case, the operator with the highest precedence is operated first.

In Java, the precedence of `*`

is higher than that of `-`

. Hence, the multiplication is performed before subtraction, and the value of `myInt` will be 4.

The table below lists the precedence of operators in Java; higher it appears in the table, the higher its precedence.

Operators | Precedence |
---|---|

postfix increment and decrement | `++` `--` |

prefix increment and decrement, and unary | `++` `--` `+` `-` `~` `!` |

multiplicative | `*` `/` `%` |

additive | `+` `-` |

shift | `<<` `>>` `>>>` |

relational | `<` `>` `<=` `>=` `instanceof` |

equality | `==` `!=` |

bitwise AND | `&` |

bitwise exclusive OR | `^` |

bitwise inclusive OR | `|` |

logical AND | `&&` |

logical OR | `||` |

ternary | `? :` |

assignment | `=` `+=` `-=` `*=` `/=` `%=` `&=` `^=` `|=` `<<=` `>>=` `>>>=` |

```
class Precedence {
public static void main(String[] args) {
int a = 10, b = 5, c = 1, result;
result = a-++c-++b;
System.out.println(result);
}
}
```

When you run the program, the output will be:

2

The operator precedence of prefix `++`

is higher than that of `-`

subtraction operator. Hence,

result = a-++c-++b;

is equivalent to

result = a-(++c)-(++b);

When dealing with multiple operators and operands in an single expression, you can use parentheses like in the above example for clarity. The expression inside the parentheses is evaluated first.

If an expression has two operators with similar precedence, the expression is evaluated according to its associativity (either left to right, or right to left). Let's take and example.

a = b = c;

Here, the value of `c` is assigned to variable `b`. Then the value of `b` is assigned of variable `a`. Why? It's because the associativity of = operator is from right to left.

The table below shows the associativity of Java operators along with their associativity.

You don't need to memorize everything here. Most of the time, the precedence and associativity of operators makes sense in itself. You can always come back to this article for reference when in doubt. Also, you can use parenthesis if you think it makes your code easier to understand.

It takes a lot of effort and cost to maintain Programiz. We would be grateful if you support us by either:

**Disabling AdBlock on Programiz. We do not use intrusive ads.**

or

Donate on Paypal