Java Operator Precedence Table and Examples

Operator precedence determines the order in which Java evaluates operators within a single expression. Just like in mathematics, multiplication and division run before addition and subtraction: in 5 + 3 * 2, the product 3 * 2 is computed first. Delimiters have the highest precedence — parentheses, array indices, and the member access operator . — followed by unary operators, while the assignment operator sits at the very bottom with the lowest precedence.

Java Operator Precedence Table

Java operators fall into several groups: arithmetic, comparison, logical, bitwise, and assignment operators. The table below lists them in descending order of precedence: level 1 is evaluated first, level 15 last. Operators on the same row share the same precedence.

One clarification about row 14: the arrow -> in a lambda expression is not an operator in terms of the Java Language Specification (JLS), and Oracle's official precedence table does not include it. It appears here informally — as a construct with very low precedence: a lambda «captures» everything to the right of the arrow, yielding only to assignment.

Associativity: Same Precedence Level

When several operators of the same precedence level appear in a row, the order is decided by associativity. Most binary operators in Java are left-associative — they are evaluated left to right:

int d = 100 - 10 - 5; // left: (100 - 10) - 5 = 85, not 100 - (10 - 5) = 95

Right-associative operators group right to left: assignment = (including compound forms), the ternary operator ? :, and unary operators:

int x, y, z;
x = y = z = 10; // right: x = (y = (z = 10)) - all three variables become 10

How such chains are evaluated step by step is covered in the lesson on the assignment operator.

Examples: How Precedence Changes the Result

Let's start with arithmetic — two expressions that look almost identical produce different results:

int a = 5 + 3 * 2;   // result: 11, since multiplication is performed first
int b = (5 + 3) * 2; // result: 16, since addition is performed first due to parentheses

As the example shows, parentheses let you change the order of operations — and significantly affect the final result.

Logical operators follow precedence rules too: && is evaluated before ||. Comparisons (level 6) rank above both, so the parentheses around them are optional, but the expression reads more easily with them:

boolean result = (5 > 3) && (10 > 8);  // true, since both conditions are true
boolean result2 = (5 > 3) || (10 < 8); // true, since at least one condition is true

boolean r = true || false && false;    // true: false && false runs first, then true || false

A combination that is easy to get wrong is mixing &, ^, and | without parentheses. Their precedence differs (& is above ^, and ^ is above |), so the result may not match your expectation:

boolean m = true, n = false, k = false;
boolean r1 = m | n & k;   // & is higher than |: evaluated as m | (n & k) = true | false = true
boolean r2 = (m | n) & k; // with parentheses: (true | false) & false = false

Without parentheses, m | n & k is true; with them, (m | n) & k is false — even though the variables are the same.