Java Operator Precedence and Associativity Guide

Concept and Fundamental Rules of Operator Precedence

Definition of Operator Precedence:
- Operator precedence is the set of rules Java uses to decide which operator gets applied first when an expression contains more than one operator.
- It represents an extension of the mathematical "order of operations" (PEMDAS) applied across all Java operators beyond standard arithmetic operations.
- Precedence directly answers the core question: in an expression lacking explicit parentheses, which operator does Java evaluate first?
Illustrations of Precedence Override:
- In the unparenthesized expression $2 + 3 \times 4 \rightarrow 14$ , the multiplication operator ( $\times$ ) outranks the addition operator ( $+$ ), causing $3 \times 4$ to be calculated first ( $12$ ), followed by adding $2$ .
- In the parenthesized expression $(2 + 3) \times 4 \rightarrow 20$ , explicit parentheses force the addition $(2 + 3)$ to be evaluated first, overriding standard operator precedence.
Definition and Function of Associativity:
- Associativity is the tie-breaking rule applied when two operators within the same expression share identical precedence levels.
- Associativity determines whether evaluation flows left-to-right or right-to-left.
- For example, the expression $20 - 5 - 3$ evaluates using left-to-right associativity for subtraction, calculating $(20 - 5) - 3 = 12$ rather than $20 - (5 - 3) = 18$

Comprehensive Breakdown of the 15 Precedence Levels

General Structure of the Precedence Hierarchy:
- Java operators are grouped into 15 discrete precedence levels, where Level 1 represents the highest priority and Level 15 represents the lowest priority.
- The ranking serves as a priority ranking read top to bottom rather than a required sequence of execution steps; an expression only evaluates through the specific levels containing operators it actually uses.
Level 1: Access and Post-fix Operators (Highest Priority):
- Operators:
  - []: Access an array element.
  - .: Access an object member.
  - (): Invoke a method.
  - ++: Post-increment.
  - --: Post-decrement.
- Associativity: Left to right.
- Functional Rationale: These operators bind tightest because their purpose is value retrieval (grabbing an array slot, a field, or a method result) prior to performing arithmetic operations on it.
- Code Example: The expression arr[i]++ first locates the array element arr[i], then increments its value.
Level 2: Unary Operators:
- Operators:
  - ++: Pre-increment.
  - --: Pre-decrement.
  - +: Unary plus.
  - -: Unary minus.
  - !: Logical NOT.
  - ~: Bitwise NOT.
- Associativity: Right to left.
- Contextual Differentiation: The symbols + and - serve dual roles in Java, functioning as unary operators at Level 2 (acting on a single value, such as -x) and binary operators at Level 5 (acting between two values, such as a - b). Context determines which operator role is active.
- Binding Rule: A unary - binds directly to the single value right next to it before anything else touches that value. Thus, -x * y evaluates as (-x) * y rather than -(x * y).
Level 3: Cast and Object Creation:
- Operators:
  - (): Cast.
  - new: Object creation.
- Associativity: Right to left.
- Roles of Parentheses (): Parentheses appear across three separate roles in the precedence table: method invocation (Level 1), grouping/cast (Level 3), and general evaluation grouping. Context determines which role is playing (e.g., (int) x is a cast, whereas doSomething() is a method call).
Level 4: Multiplicative Operators:
- Operators:
  - *: Multiplication.
  - /: Division.
  - %: Modulus (remainder).
- Associativity: Left to right.
Level 5: Additive Operators:
- Operators:
  - +: Addition.
  - -: Subtraction.
  - +: String concatenation.
- Associativity: Left to right.
- Dual Functionality of +: The + symbol handles numeric addition and string concatenation, with Java determining the operation based on the types of the operands.
- Concatenation Examples:
  - "Score: " + 2 + 3 produces "Score: 23". Evaluated left-to-right, the string plus the number 2 becomes "Score: 2", which then concatenates with 3 to keep producing "Score: 23".
  - "Score: " + (2 + 3) produces "Score: 5" because parentheses force arithmetic addition of 2 + 3 first.
Level 6: Shift Operators:
- Operators:
  - <<: Left shift.
  - >>: Signed right shift.
  - >>>: Unsigned right shift.
- Associativity: Left to right.
Level 7: Relational Operators:
- Operators:
  - <: Less than.
  - <=: Less than or equal to.
  - >: Greater than.
  - >=: Greater than or equal to.
  - instanceof: Type comparison.
- Associativity: Left to right.
Level 8: Equality Operators:
- Operators:
  - ==: Equal to.
  - !=: Not equal to.
- Associativity: Left to right.
- Precedence Interaction: Equality sits at a lower level than relational comparisons (<, >, etc.). Consequently, x < y == a < b is legal and parses as (x < y) == (a < b).
Levels 9–11: Bitwise Logical Operators (Single Symbol):
- Level 9: & (Bitwise AND)
- Level 10: ^ (Bitwise XOR)
- Level 11: | (Bitwise OR)
- Associativity: Left to right for each individual level.
- Evaluation Properties:
  - These operators exist in strict order: AND before XOR before OR.
  - Each bitwise logical operator is lower precedence than equality.
  - Unlike conditional logical operators (&&, ||), bitwise operators are evaluated at a lower tier and always evaluate both sides without short-circuiting.
Levels 12–13: Conditional Logical Operators (Double Symbol):
- Level 12: && (Conditional AND with short-circuit)
- Level 13: || (Conditional OR with short-circuit)
- Associativity: Left to right for each individual level.
- Precedence Advantage: && and || are lower precedence than every comparison and bitwise operator above them. This allows an expression like x > 0 && y > 0 to work without parentheses, as Java evaluates both comparisons completely before applying && to their true/false results.
Level 14: Conditional (Ternary) Operator:
- Operator: ?: (Conditional ternary operator).
- Associativity: Right to left.
Level 15: Assignment Operators (Lowest Priority):
- Operators:
  - =, +=, -=, *=, /=, %=: Assignment and compound assignment.
  - &=, ^=, |=: Bitwise compound assignment.
  - <<=, >>=, >>>=: Shift compound assignment.
- Associativity: Right to left.
- Evaluation Order Rule: Assignment operators are evaluated last, no matter what.
- Expression Resolution Example: In a statement like int total = a + b * c;, Java first fully evaluates the entire right-hand expression (a + b * c, using every rule above) and only after that result is final does it perform the assignment into total.
- Chained Assignment Example: Because assignment is right-to-left, a chain like x = y = z = 5; works as expected: z = 5 happens first, then that result is assigned to y, then to x.

Conceptual Structure and Expression Life Cycle

Underlying Organization of the Precedence Hierarchy:
- Reading top to bottom, the precedence table moves through Java's operators in order of conceptual distance from a raw value across eight steps:
  1. Access the value: Array index, object member, method call ([], ., ()) — Level 1.
  2. Modify a single value: Unary +/-, NOT, pre-increment (++, --, !, ~) — Level 2.
  3. Convert or construct a value: Type cast, new — Level 3.
  4. Combine two values arithmetically: Multiplicative (*, /, %) then additive (+, -) — Levels 4–5.
  5. Shift and compare values: Shift operators, relational operators, equality operators — Levels 6–8.
  6. Combine true/false results: Bitwise operators (&, ^, |) then logical operators (&&, ||) — Levels 9–13.
  7. Choose between two results: Conditional ternary operator (?:) — Level 14.
  8. Store a result: Assignment operators (= and compound variants) — Level 15.
The Natural Life Cycle of an Expression:
- The table tracks the natural life cycle of an expression: Retrieve $\rightarrow$ Transform $\rightarrow$ Combine $\rightarrow$ Compare $\rightarrow$ Decide $\rightarrow$ Store.

Summary of Key Rules and Practical Takeaways

Order vs. Correctness:
- Precedence is about order, not correctness. Every one of these expressions is legal Java; precedence just determines the resulting output.
Role of Associativity in Tie-Breaking:
- When two operators tie on precedence, associativity breaks the tie.
- Left-to-Right: Applies to almost all operator levels.
- Right-to-Left: Notably applies to unary operators, casting, the ternary operator, and all assignment operators.
Reference Table Application:
- The precedence table functions as a core reference to return to whenever individual operators (such as instanceof, bitwise operators, or >>>) are used.
Primary Assignment Rule:
- Assignment always happens last.
- Whatever is on the right-hand side of = is fully resolved before it is stored in the variable on the left-hand side.