Java Operator Precedence

In Java, operator precedence defines the order in which operators are evaluated in an expression. Operators with higher precedence are evaluated before operators with lower precedence. If operators have the same precedence, they are evaluated from left to right, following the associativity rule. Here is a list of Java operators in descending order of precedence:

Postfix operators: expr++, expr--
Prefix operators: ++expr, --expr
Unary operators: +, -, !, ~
Type cast: (type) expr
Multiplicative operators: *, /, %
Additive operators: +, -
Bitwise shift operators: <<, >>, >>>
Relational operators: <, >, <=, >=, instanceof
Equality operators: ==, !=
Bitwise AND: &
Bitwise XOR: ^
Bitwise OR: |
Logical AND: &&
Logical OR: ||
Ternary conditional operator: ? :
Assignment operators: =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>=

Here's an example that demonstrates Java operator precedence:

int a = 5;
int b = 10;
int c = 2;

int result = a + b * c - a / c; // Equivalent to: a + (b * c) - (a / c)

In the example, the multiplication operator * and the division operator / have higher precedence than the addition operator + and the subtraction operator -. Therefore, b * c and a / c are evaluated first, followed by the addition and subtraction operations.

Java Operator Precedence Table:

Operator precedence determines the order in which operators are evaluated. Here's a concise table:

Category	Operators
Postfix	`expr++ expr--`
Unary	`++expr --expr +expr -expr ~ !`
Multiplicative	`* / %`
Additive	`+ -`
Shift	`<< >> >>>`
Relational	`< > <= >= instanceof`
Equality	`== !=`
Bitwise AND	`&`
Bitwise XOR	`^`
Bitwise OR	`
Logical AND	`&&`
Logical OR	`
Conditional	`? :`
Assignment	`= += -= *= /= %= &= ^=

Operator Precedence in Java Examples:
- Examples illustrating the order of evaluation based on operator precedence:
```
int result = 10 + 5 * 2; // result is 20, multiplication first
```
Java Arithmetic Operator Precedence:
- Arithmetic operators have higher precedence than most other operators.
```
int result = 10 + 5 * 2; // result is 20, multiplication first
```
Logical Operator Precedence in Java:
- Logical operators (&&, ||) have lower precedence than most other operators.
```
boolean result = true || false && true; // result is true, && has higher precedence
```
Bitwise Operator Precedence in Java:
- Bitwise operators (&, |, ^) have lower precedence than most arithmetic operators.
```
int result = 5 & 3 | 1; // result is 5, & has higher precedence
```
Comparison Operator Precedence in Java:
- Comparison operators (<, >, <=, >=, ==, !=) have higher precedence than logical operators.
```
boolean result = 10 > 5 || 3 != 2; // result is true, > has higher precedence
```
Assignment Operator Precedence in Java:
- Assignment operators (=, +=, -=, *=, /=, %=) have lower precedence than most other operators.
```
int x = 5;
x += 3 * 2; // x is 11, multiplication first, then addition
```
Conditional Operator Precedence in Java:
- The conditional operator (? :) has lower precedence than most other operators.
```
int result = (5 > 3) ? 10 : 5; // result is 10, ternary operator
```
Java Unary Operator Precedence:
- Unary operators (++, --, +, -, ~, !) have higher precedence than most other operators.
```
int x = -5;
int result = ++x * 2; // result is -8, unary first, then multiplication
```
Java Ternary Operator Precedence:
- The ternary operator (? :) has lower precedence than most other operators.
```
int result = (5 > 3) ? 10 : 5; // result is 10, ternary operator
```
Java Order of Evaluation and Operator Precedence:
- The order of evaluation is from left to right, respecting operator precedence. Parentheses can be used to override default order.
```
int result = 10 + 5 * 2; // result is 20, multiplication first
```
Operator Precedence and Associativity in Java:
- Operators with the same precedence follow associativity rules (left-to-right or right-to-left). For example, addition and subtraction have the same precedence and associate left-to-right.
```
int result = 10 - 5 + 2; // result is 7, left-to-right associativity
```
Java Expression Evaluation Rules:
- Expressions are evaluated based on operator precedence and associativity rules. Parentheses can be used to override default order.
```
int result = (10 + 5) * 2; // result is 30, parentheses override
```
Common Mistakes with Java Operator Precedence:
- Mistakes often occur when assuming default left-to-right associativity. Parentheses can help clarify and avoid errors.
```
int result = 10 + 5 * 2; // result is 20, multiplication first
```