Operator Precedence

Beginner ~15 min read

When an expression has multiple operators (e.g., 5 + 2 * 3), Java needs to know which one to calculate first. This is determined by operator precedence.

Why It Matters

Just like in math class (PEMDAS), multiplication happens before addition.

int x = 5 + 2 * 3; 
// 2 * 3 = 6
// 5 + 6 = 11
// Result: 11 (NOT 21)

Precedence & Associativity Table

Operators at the top are evaluated first.

Category	Operators	Associativity
Postfix	`expr++` `expr--`	Left to Right
Unary	`++expr` `--expr` `+expr` `-expr` `~` `!`	Right to Left
Multiplicative	`*` `/` `%`	Left to Right
Additive	`+` `-`	Left to Right
Shift	`<<` `>>` `>>>`	Left to Right
Relational	`<` `>` `<=` `>=` `instanceof`	Left to Right
Equality	`==` `!=`	Left to Right
Bitwise AND	`&`	Left to Right
Bitwise XOR	`^`	Left to Right
Bitwise OR	`\|`	Left to Right
Logical AND	`&&`	Left to Right
Logical OR	`\|\|`	Left to Right
Ternary	`? :`	Right to Left
Assignment	`=` `+=` `-=` `*=` etc	Right to Left

public class OperatorPrecedence {
    public static void main(String[] args) {
        // Multiplication before Addition
        int result1 = 5 + 2 * 3;
        System.out.println("5 + 2 * 3 = " + result1); // 11

// Using Parentheses
        int result2 = (5 + 2) * 3;
        System.out.println("(5 + 2) * 3 = " + result2); // 21

// Division/Multiplication (Left to Right)
        // 10 / 2 = 5, then 5 * 5 = 25
        int result3 = 10 / 2 * 5;
        System.out.println("10 / 2 * 5 = " + result3); // 25

// NOT (10 / (2*5)) = 1

// Complex example
        // 1. (3+1) = 4
        // 2. 4*4 = 16
        // 3. 50-16 = 34
        int complex = 50 - 4 * (3 + 1);
        System.out.println("50 - 4 * (3 + 1) = " + complex);

// Pre-increment vs Post-increment precedence
        int a = 5;
        int b = 10;
        // ++a happens first (makes a=6)
        // Then * happens (6 * 10 = 60)
        int res4 = ++a * b;
        System.out.println("++a * b = " + res4);
    }
}

Output

Click Run to execute your code

Controlling Order with Parentheses

Parentheses () have the highest precedence. You can use them to force evaluations in the order you want.

Best Practice: Don't rely on remembering the entire precedence table. If an expression is complex, use parentheses to make your intent clear.
a + b * c vs a + (b * c)

Summary

Operators with higher precedence are evaluated first.
Multiplication/Division happen before Addition/Subtraction.
Assignment = has very low precedence (happens last).
Use parentheses () to explicitly define the order of operations and improve code readability.

Previous Ternary Operator

Next Next Module: Control Flow →

Why It Matters

Precedence & Associativity Table

Controlling Order with Parentheses

Summary

Enjoying these tutorials?