Qfyilyi

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 Java Language Specification that dictates loading 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 evaluates to true? I would have expected (x = y) to be evaluated first, and then it would compare x with itself (3) and return true.

== 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 sad, 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.