Why highest priority operation [ ] is not evaluated first ini = i + arr[i++] + arr[i++]?

Question

[ ] priority is highest (anyway is higher than +). But in RHS of expression below the first (leftmost) summand (i) is evaluated before the second summand arr1[i++], because i++ of arr1[i++] does not influence value of the first (leftmost) summand (i which is 1 and not changed).

I cannot strictly explain why higher priority [ ] is not evaluated first.

int[] arr = { 0, 0, 0 };
int i = 1;
i = i + arr[i++] + arr[i++];
System.out.println(i); // output is zero

Why would you write such unreadable code? Check your assumptions. The JVM knows what it's doing. — duffymo, Feb 27 '18 at 16:36
How do you know the operations are done in a particular order? Let's see the contents of the arrays and the final value of `i` — Bohemian, Feb 27 '18 at 16:36
it is a certification question. I care about my understanding. Sure I would never write such code... — inqi777, Feb 27 '18 at 16:37
I would hope this certification question has an answer like `z) Just don't do this -- ever.` — Fred Larson, Feb 27 '18 at 16:38
@Bohemian Maybe I am mistaken. My question is about "What is the exact order of operations and why?" — inqi777, Feb 27 '18 at 16:39
@inqi777 no that was not your question. Your question was *why `[]` is not evaluated first*. — Bohemian, Feb 27 '18 at 16:40
FYI: There's no way the output in your example can be zero. `i` is non-zero. — Makoto, Feb 27 '18 at 16:43

Makoto · Answer 1 · 2018-02-27T16:47:50.727

0

This behaves how I'd expect it to, frankly. The operator precedence seems correct.

Given this sample code, we would expect the result to not be negative.

int[] arr = {-1000, 100, 150};
int i = 1;
i = i + arr[i++] + arr[i--];
System.out.println(i);

Here's what happens.

+ associates right-to-left, but it has a lower priority than [], so it is not invoked yet.
arr[i++] resolves first, and results in 100, with i == 2.
arr[i--] resolves next, and results in 150, with i == 1.
+ resolves next, left to right, and adds 150 + 100 + 1.
The answer then becomes 251.

So, to answer your question...yes, the array access is happening first.

edited Feb 27 '18 at 16:47

answered Feb 27 '18 at 16:39

Makoto

104,088
27
192
230

Please see example I added to the post... – inqi777 Feb 27 '18 at 16:42
For your example, the output is 1. I'm not sure where you got mixed up on *that* one... – Makoto Feb 27 '18 at 16:43

xingbin · Accepted Answer · 2018-02-27T17:16:22.090

See jls Evaluate Operands before Operation:

The Java programming language guarantees that every operand of an operator (except the conditional operators &&, ||, and ? :) appears to be fully evaluated before any part of the operation itself is performed.

and Evaluate Left-Hand Operand First

The left-hand operand of a binary operator appears to be fully evaluated before any part of the right-hand operand is evaluated.

The most left operand is evaluated as 1 before i++.

Why highest priority operation [ ] is not evaluated first ini = i + arr[i++] + arr[i++]?

2 Answers2