Csdrhrt

Consider the following example:

class Quirky {

    public static void main(String args) {

        int x = 1;

        int y = 3;



        System.out.println(x == (x = y)); // false

        x = 1; // reset

        System.out.println((x = y) == x); // true

     }

}

I'm not sure if there is an item in the Java Language Specification that dictates loading the previous value of a variable for comparison with the right side (x = y) which, by the order implied by brackets, should be calculated first.

Why does the first expression evaluate to false, but the second evaluate to true? I would have expected (x = y) to be evaluated first, and then it would compare x with itself (3) and return true.

This question is different from order of evaluation of subexpressions in a Java expression in that x is definitely not a 'subexpression' here. It needs to be loaded for the comparison rather than to be 'evaluated'. The question is Java-specific and the expression x == (x = y), unlike far-fetched impractical constructs commonly crafted for tricky interview questions, came from a real project. It was supposed to be a one-line replacement for the compare-and-replace idiom

int oldX = x;

x = y;

return oldX == y;

which, being even simpler than x86 CMPXCHG instruction, deserved a shorter expression in Java.

== is a binary equality operator.

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

^{Java 11 Specification > Evaluation Order > Evaluate Left-Hand Operand First}

As LouisWasserman said, the expression is evaluated left to right. And java doesn't care what "evaluate" actually does, it only cares about generating a (non volatile, final) value to work with.

//the example values

x = 1;

y = 2;

So in quickReplaceAndCompare() the following is done:

x == (x = y)

1 == (x = y)

1 == (x = 2) //assign 2 to x, returns 2

1 == 2

false

and in badReplaceAndCompare():

(x = y) == x

(x = 2) == x //assign 2 to x, returns 2

2 == x

2 == 2

true

Note that badReplaceAndCompare() will always return true, because you are effectively comparing the assignment of a value to the variable it is assigned to, and a = b and b will, evaluated in that order, always be the same by definition.

which, by the order implied by brackets, should be calculated first

No. It is a common misconception that parentheses have any (general) effect on calculation or evaluation order. They only coerce the parts of your expression into a particular tree, binding the right operands to the right operations for the job.

(And, if you don't use them, this information comes from the "precedence" and associativity of the operators, something that's a result of how the language's syntax tree is defined. In fact, this is still exactly how it works when you use parentheses, but we simplify and say that we're not relying on any precedence rules then.)

Once that's done (i.e. once your code has been parsed into a program) those operands still need to be evaluated, and there are separate rules about how that is done: said rules (as Andrew has shown us) state that the LHS of each operation is evaluated first in Java.

Note that this is not the case in all languages; for example, in C++, unless you're using a short-circuiting operator like && or ||, the evaluation order of operands is generally unspecified and you shouldn't rely on it either way.

Teachers need to stop explaining operator precedence using misleading phrases like "this makes the addition happen first". Given an expression x * y + z the proper explanation would be "operator precedence makes the addition happen between x * y and z, rather than between y and z", with no mention of any "order".

In the first test you're checking does 1 == 3.

In the second test your checking does 3 == 3.

(x = y) assigns the value and that value is tested. In the former example x = 1 first then x is assigned 3. Does 1 == 3?

In the latter, x is assigned 3, and obviously it's still 3. Does 3 == 3?

It is related to operator precedence and how operators are getting evaluated.

Parentheses '()' has higher precedence and has associativity left to right.
Equality '==' come next in this question and has associativity left to right.
Assignment '=' come last and has associativity right to left.

System use stack to evaluate expression. Expression gets evaluated left to right.

Now comes to original question:

int x = 1;

int y = 3;

System.out.println(x == (x = y)); // false

First x(1) will be pushed to stack.
then inner (x = y) will be evaluated and pushed to stack with value x(3).
Now x(1) will be compared against x(3) so result is false.

x = 1; // reset

System.out.println((x = y) == x); // true

Here,
(x = y) will be evaluated, now x value become 3 and x(3) will be pushed to stack.
Now x(3) with changed value after equality will be pushed to stack.
Now expression will be evaluated and both will be same so result is true.