JAVA operator precedence table is wrong.

Question

I can not understand why JAVA auto-increment/decrement operator does not follow the rules of Operator Precedence table at http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html
The precedent order is as follow:
postfix: expr++ expr--
unary: ++expr --expr +expr -expr ~ !
multiplicative: * / %
From the above we know that x++/x-- is higher then ++x/--x and multiplicative is the lower then both.
I tested the following in JAVA:
int y,x = 2;
y = --x * x++;
System.out.println(x); //Output is 1.
Why?
Theoretically, x++ must be performed before --x, finally then the multiplication (*) and the answer should be
x++ value=2, stored variable=3
--x value=2, stored variable=2
Therefore 2 * 2 = 4.
Why JAVA is not following the rules that it setup for itself??
After much research, my conclusion is JAVA Operator Precedence table in java.sun.com website is wrong. The right version should be the same as this website: http://www.sorcon.com/java2/precedence.htm.
Please run your example code in JAVA before you want to prove me wrong.
Thank you.

Answer 1

Hi jsalonen, thank you for your reply. Yes, I see your theory but sorry to say that I don't agree with you. Let's take your example -x++ for our discussion below:
First let's agree with this:
x = 2;
y = -x;
System.out.println("y = " + y); // y = -2
System.out.println("x = " + x); // x = 2
From the above, we can see that by using the negation operator doesn't mean that we have changed the value of x variable. The system just assigns the value of x to the expression but still keeping the value of variable x. That's why we got the output above, agree?
Now, let's evaluate your example:
int y, x = 2;
y = -x++;
System.out.println("y = " + y); // -2
System.out.println("x = " + x); // 3
Hence below is the sequence of process:
1. -x is evaluated first. Value in variable x is assigned to the expression. At this point the value of x is 2 and this value get negated. However the variable x still storing 2.
2. Now x++ get evaluated, since this is a postfix increment operator, the value will get assigned first then increase. However x is already assigned, we can not assign it twice, just like if you perform x++ first, you have assigned x then increase and you didn't assign it again for the negation operator. If you did, x would be 3 and get negated to -3. Note that system also cannot perform 2++ because 2 is not a variable. Therefore it is logical to say that x is assigned to the expression and got negated by negation operator then increase the varaible x by 1. So here we increase the value of x by 1 and the result is 3. Therefore variable x is storing 3.
Now, try the follwing
x = 2;
y = -x + x++;
What is the value of x after -x? It's 2. Remember 2 is assign back to expression but x still retained the original value. If not we would expect x++ to be (-2)++, right?
But see the output for yourself:
System.out.println("y = " + y); // 0
System.out.println("x = " + x); // 3
As for the subexpression theory, sorry to say that I don't agree with you as well. See the expression below:
y = -x + x++;
We can identify that there are 4 operators in this statement, right? (assignment operator, negation operator, addition operator and increment operator)
since JAVA has defined all the operators in the table and already given each of them a priory and associativity, I don't see any subexpression here. If yes why didn't they mention about subexpression rule in the table? Shouldn't that be defined explicitly so that it doesn't confuse people?
In conclusion, I still think that JAVA need to correct the operators precedence table at http://java.sun.com/docs/books/tutorial/java/nutsandbolts/operators.html so that they don't confused people for another 10 years. :) Moreover the table is not complete because it did not include . and [ ] and (params) operators.