为什么x ==（x = y）与（x = y）== x不同？

考虑以下示例：

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
     }
}

我不确定Java语言规范中是否有一项规定要加载变量的先前值以便与右侧（x = y）进行比较，根据括号中的顺序，应该首先计算该右侧（）。

为什么第一个表达式求值false，而第二个表达式求值true？我本来希望(x = y)先被评估，然后再x与自身（3）比较并返回true。

这个问题与Java表达式中子表达式的求值顺序不同，因为x这里绝对不是“子表达式”。需要加载它以进行比较，而不是对其进行“评估”。这个问题是特定于Java的x == (x = y)，与通常为棘手的面试问题设计的牵强的不切实际的构造不同，该表达式来自一个真实的项目。它原本应该是“一键替换”成语的单行替换

int oldX = x;
x = y;
return oldX == y;

它比x86 CMPXCHG指令还要简单，因此值得在Java中使用较短的表达式。

应按括号中的顺序先计算

不会。圆括号对计算或评估顺序有任何（一般）影响，这是一个普遍的误解。它们仅将表达式的部分强制转换为特定的树，将正确的操作数绑定到作业的正确操作。

（而且，如果您不使用它们，则此信息来自运算符的“优先级”和关联性，这是语言的语法树定义方式的结果。实际上，这仍然是您使用语言时的工作方式使用括号，但我们简化并说我们当时不依赖任何优先级规则。）

一旦完成（即，将您的代码解析为程序），仍然需要对那些操作数进行求值，并且有关于如何完成操作的单独规则：所述规则（如安德鲁向我们展示的那样）指出每个操作的LHS首先用Java评估。

请注意，并非所有语言都如此。例如，在C ++中，除非您使用短路运算符（如&&或）||，否则操作数的评估顺序通常是不确定的，并且您不应以任何方式依赖它。

教师需要停止使用误导性短语来解释操作员优先级，例如“这使添加操作首先发生”。给定一个表达式x * y + z，正确的解释是“运算符优先级使x * y和z之间发生加法，而不是y和之间发生加法，而z没有提及任何”顺序”。

==是二进制相等运算符。

在评估右侧操作数的任何部分之前，似乎已对二进制运算符的左侧操作数进行了完全评估。

^{Java 11规范>评估顺序>首先评估左手操作数}

正如LouisWasserman所说，该表达式是从左到右求值的。Java并不关心“评估”的实际作用，它只关心生成一个（非易失性的，最终的）值以供使用。

//the example values
x = 1;
y = 3;

因此，要计算的第一个输出System.out.println()，请执行以下操作：

x == (x = y)
1 == (x = y)
1 == (x = 3) //assign 3 to x, returns 3
1 == 3
false

并计算第二个：

(x = y) == x
(x = 3) == x //assign 3 to x, returns 3
3 == x
3 == 3
true

需要注意的是第二个值将始终为true，无论初始值的x和y，因为你有效地比较值将其分配给变量的赋值，a = b并b会以该顺序进行评估，始终是相同的根据定义。

我不确定Java语言规范中是否有一项规定要加载变量的先前值...

有。下次您不清楚规格说明时，请阅读规格说明，然后询问是否不清楚。

... (x = y)应按照括号中的顺序先计算右侧。

那句话是错误的。括号并不意味着评估的顺序。在Java中，不管括号如何，评估顺序都是从左到右。括号确定子表达式边界的位置，而不是求值顺序。

为什么第一个表达式的计算结果为false，而第二个表达式的计算结果为true？

==运算符的规则是：评估左侧以产生一个值，评估右侧以产生一个值，比较这些值，比较是表达式的值。

换句话说，的含义expr1 == expr2始终与您先编写temp1 = expr1; temp2 = expr2;然后求值相同temp1 == temp2。

对于在=左侧具有局部变量的运算符，规则是：评估左侧以生成变量，评估右侧以生成值，执行赋值，结果是已赋值。

所以放在一起：

x == (x = y)

我们有一个比较运算符。评估左侧以产生一个值-我们得到的当前值x。评估右侧：这是一个赋值，因此我们评估左侧以产生一个变量-该变量x-我们评估右侧-的当前值y-将其赋值给x，结果就是赋值。然后，我们将的原始值与x分配的值进行比较。

您可以(x = y) == x作为练习来做。同样，请记住，所有评估左侧的规则都发生在所有评估右侧的规则之前。

我本来希望（x = y）首先被评估，然后它将x与自身（3）进行比较并返回true。

您的期望是基于对Java规则的一系列错误信念。希望您现在拥有正确的信念，并且将来会期待真实的事情。

这个问题不同于“ Java表达式中子表达式的求值顺序”

这句话是错误的。这个问题完全贴切。

x绝对不是此处的“子表达式”。

这句话也是错误的。在每个示例中，它都是一个子表达式两次。

需要加载它以进行比较，而不是对其进行“评估”。

我不知道这是什么意思。

显然，您仍然有许多错误的信念。我的建议是您阅读规范，直到您的错误信念被真实信念取代。

这个问题是特定于Java的，并且表达式x ==（x = y）与通常为棘手的面试问题设计的牵强的不切实际的构造不同，它来自一个真实的项目。

该表述的出处与该问题无关。在说明书中清楚地描述了这种表达的规则。阅读！

它本来是用于替换和替换成语的单行替换

由于单行替换在您（代码的阅读者）中引起了很大的混乱，我建议这是一个糟糕的选择。使代码更简洁但更难理解并不是胜利。不太可能使代码更快。

顺便说一句，C＃将比较和替换作为库方法，可以将其简化为机器指令。我相信Java没有这种方法，因为它不能在Java类型系统中表示。

它与运算符优先级以及运算符的评估方式有关。

括号“（）”具有较高的优先级，并且从左到右具有关联性。等式“ ==”在此问题中排在第二位，并且具有从左到右的关联性。分配“ =”位于最后，并且具有从右到左的关联性。

系统使用堆栈来评估表达式。表达式从左到右求值。

现在来看原始问题：

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

第一个x（1）将被压入堆栈。然后将评估内部（x = y）并将其推入值x（3）的堆栈。现在将x（1）与x（3）进行比较，因此结果为false。

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

在这里，将计算（x = y），现在x值变为3，x（3）将被压入堆栈。现在等式后具有更改值的x（3）将被压入堆栈。现在将对表达式进行评估，并且两者将相同，因此结果为true。

不一样 左手总是在右手之前求值，方括号不指定执行顺序，而是一组命令。

带有：

      x == (x = y)

基本上，您的操作与：

      x == y

和X将价值ÿ比较之后。

同时使用：

      (x = y) == x

基本上，您的操作与：

      x == x

x 之后取y的值。并且它将始终返回true。

在第一个测试中，您要检查1 == 3。

在第二个测试中，您的检查是3 == 3。

（x = y）分配值，并测试该值。在前面的示例中，首先x = 1，然后分配x。1 == 3吗？

在后者中，x被分配为3，并且显然仍为3。3 == 3吗？

考虑另一个更简单的示例：

int x = 1;
System.out.println(x == ++x); // false
x = 1; // reset
System.out.println(++x == x); // true

在这里，++x必须在进行比较之前应用pre-increment运算符-就像(x = y)在您的示例中一样，必须在比较之前计算得出。

但是，表达式求值仍然是从→→向右进行，因此第一个比较实际上是，1 == 2而第二个比较是2 == 2。
您的示例中发生了同样的事情。

表达式从左到右求值。在这种情况下：

int x = 1;
int y = 3;

x == (x = y)) // false
x ==    t

- left x = 1
- let t = (x = y) => x = 3
- x == (x = y)
  x == t
  1 == 3 //false

(x = y) == x); // true
   t    == x

- left (x = y) => x = 3
           t    =      3 
-  (x = y) == x
-     t    == x
-     3    == 3 //true

基本上，第一个语句x的值为1，因此Java将1 ==与新的x变量进行比较，该变量不会相同

在第二个中，您说x = y，这意味着x的值已更改，因此当您再次调用它时，它将是相同的值，因此为什么它为true并且x == x

==是一个比较相等运算符，它从左到右起作用。

x == (x = y);

这里将x的旧分配值与x的新分配值进行比较（1 == 3）// false

(x = y) == x;

而在这里，x的新赋值与比较之前分配给它的x的新保持值进行比较，（3 == 3）// true

现在考虑一下

    System.out.println((8 + (5 * 6)) * 9);
    System.out.println(8 + (5 * 6) * 9);
    System.out.println((8 + 5) * 6 * 9);
    System.out.println((8 + (5) * 6) * 9);
    System.out.println(8 + 5 * 6 * 9);

输出：

342

278

702

342

278

因此，括号仅在算术表达式中发挥其主要作用，而在比较表达式中则不起作用。

这里的东西是arithmatic运营商/关系运算符precedency为了出这两家运营商的=VS ==优势之一是==（关系运算符占主导地位），因为它先=赋值运算符。尽管具有优先级，但评估顺序为LTR（从左到右），评估顺序后优先级出现。因此，无论约束评估是什么，LTR都是如此。

很容易在左边的第二个比较中，在将y赋给x之后（左边），然后比较3 == 3。总是从x的左到右采用当前状态读取语句。

如果您要编写Java编译器或测试程序以验证Java编译器是否正常运行，那么您提出的问题是一个很好的问题。在Java中，这两个表达式必须产生您看到的结果。例如，在C ++中，它们不必这样做-因此，如果有人在其Java编译器中重用了C ++编译器的某些部分，则从理论上讲，您可能会发现该编译器的运行不正常。

作为软件开发人员，编写可读性，可理解性和可维护性的代码，这两个版本的代码都将被认为很糟糕。要了解代码的作用，必须确切地知道Java语言是如何定义的。既写Java代码又写C ++代码的人会不寒而栗。如果您必须问为什么一行代码可以完成它，那么您应该避免使用该代码。（我想并希望那些正确回答了“为什么”问题的人也会避免使用该代码）。