Ejecución del operador de asignación Java

¡Buena pregunta! Y la JLS tiene la respuesta...

§15.12.4.1 (Ejemplo 15.12.4.1-2). Orden De Evaluación Durante La Invocación Del Método:

Como parte de una invocación de método de instancia, hay una expresión que denota el objeto a invocar. Esta expresión parece ser plenamente evaluado antes de cualquier parte de cualquier expresión de argumento al método se evalúa la invocación.

Así que, en:

String x = "hello";
String y = "goodbye";
System.out.println(x.equals(x = y));

La aparición de x antes .equals se evalúa primero, antes del argumento expression x = y.

Por lo tanto, una referencia a la cadena hello se recuerda como la referencia de destino antes de que la variable local x se cambie para referirse a la cadena goodbye. Como resultado, el método equals se invoca para el objeto de destino hello con el argumento goodbye, por lo que el resultado de la invocación es false.

Es importante recordar que un String en java es un objeto, y por lo tanto una referencia. Cuando llamas

x.equals(...)

Está comprobando si el valor en la ubicación actualmente referenciada por x es igual a lo que está pasando. Dentro, está cambiando el valor que x es haciendo referencia a, pero todavía está llamando a equals con la referencia original (la referencia a "hola"). Por lo tanto, en este momento su código está comparando para ver si "hola" es igual a "adiós", que claramente no lo es. Después de este punto, si utiliza x de nuevo, resultará en una referencia al mismo valor que y.

x=y en el paréntesis significa que la expresión (x=y) es ahora goodbye, mientras que la x externa en x.equals contiene el valor hello

Reimus dio la respuesta correcta, pero me gustaría explicar.

En Java (y la mayoría de los lenguajes) la convención es variable va a la izquierda, asignación a la derecha.

Vamos a desglosarlo:

String x = "hello";
//x <- "hello"

String y = "goodbye";
//y <- "goodbye";

Para fines de depuración, así como para la legibilidad del código, siempre es una buena práctica dividir las líneas para que solo hagan una cosa.

System.out.println(x.equals(x = y)); //Compound statement

Aquí, x.equals(...) se llama en la referencia original a x, o "hola", se actualiza para la segunda referencia.

I escribiría esto como (y esto le dará su respuesta esperada):

x = y;
// x <- y = "goodbye"

boolean xEqualsX = x.equals(x);
// xEqualsX <- true

System.out.println(xEqualsX);
// "true"

Ahora bien, esto parece obvio que debe comportarse de esta manera, pero también es muy fácil ver exactamente lo que está sucediendo en cada línea, que es algo por lo que debes esforzarte.

He intentado su pregunta en eclipse sus dos expresiones son correctas. 1) x == (y = x) evaluar a verdadero es verdad porque el valor de x asigna a y que es 'hola' entonces x e y comparan ellos el mismo resultado será verdadero

2) x. igual (x = y) es falso debido a que el valor de y asignar a x que es adiós entonces x y x comparar su valor será diferente por lo que el resultado será false

Veo la pregunta en términos laicos como "hello".equals("goodbye"). Así que devuelve false.

En java String es una clase.

String x = "hello";
String y = "goodbye"; 

Es una cadena diferente de dos que se refieren a dos valores diferentes que no son iguales y si comparas

 System.out.println(x.equals(x = y)); 
//this compare value (hello and goodbye) return true

    System.out.println(x == (y = x)); 
// this compare reference of an object (x and y) return false  

Está viendo si x. equals (asignar x a y, devuelve true siempre) así que básicamente x. es igual a (verdadero)