Java：前置，后置运算符优先级

Question

关于 Java 中的运算符优先级，我有两个类似的问题。

第一个：

int X = 10;
System.out.println(X++ * ++X * X++); //it prints 1440 

根据Oracle tutorial:
后缀 (expr++, expr--) 运算符的优先级高于前缀 (++expr, --expr)

所以，我假设评估顺序：

1) first postfix operator: X++ 
   1.a) X++ "replaced" by 10
   1.b) X incremented by one: 10+1=11
   At this step it should look like:  System.out.println(10 * ++X * X++), X = 11;

2) second POSTfix operator: X++ 
   2.a) X++ "replaced" by 11
   2.b) X incremented by one: 11+1=12
   At this step it should look like:  System.out.println(10 * ++X * 11), X = 12;

3) prefix operator: ++X
   3.a) X incremented by one: 12+1=13
   3.b) ++X "replaced" by 13
   At this step it should look like:  System.out.println(10 * 13 * 11), X = 13;

4) evaluating 10*13 = 130, 130*11 = 1430.

但 Java 似乎忽略了 PRE/POST 排序并将它们放在一个级别上。所以真正的顺序：

 X++ -> ++X -> X++ 

是什么导致答案为 (10 * 12 * 12) = 1440。

第二个：

Example from this question:

    int a=1, b=2;             
    a = b + a++;

部分接受的答案： “在分配时，++ 已经将a 的值增加到2（由于优先级），所以= 会覆盖增加的值。”

好的，我们一步一步看：

 1) replacing "b" with 2
 2) replacing "a++" with 1
 3) incrementing "a" by 1 -> at this point a==2
 4) evaluating 2+1 = 3
 5) overwriting incremented value of "a" with 3

似乎一切都很好。 但是让我们对代码做一点改动（将“=”替换为“+=”）

    a += b + a++;

步骤 1-4 应与上述相同。 所以，在第 4 步之后，我们有类似的东西：

    a += 3;

在哪里a==2

然后我想：好的，a = 2+3，所以a 应该是5。但答案只有4

我真的很困惑。我已经花了几个小时，但仍然无法理解我错在哪里。

附：我知道，我不应该在实际应用程序中使用这种“风格”。我只是想了解我的想法有什么问题。

Answer 1

混淆源于操作数从左到右求值这一事实。 首先完成此操作，然后再关注运算符的优先级/操作顺序。

此行为在JLS 15.7.2. Evaluate Operands before Operation 中指定

所以X++ * ++X * X++ 首先被评估为10 * 12 * 12，如您所见，它产生1440。

要让自己相信这一点，请考虑以下几点：

X = 10; System.out.println(X++ * ++X);
X = 10; System.out.println(++X * X++);

如果先完成X++，然后是++X，然后是乘法，两者都应该打印相同的数字。

但他们没有：

X = 10; System.out.println(X++ * ++X); // 120
X = 10; System.out.println(++X * X++); // 121

那么这有什么意义呢？好吧，如果我们意识到操作数是从左到右计算的，那么它就很有意义了。

X = 10; System.out.println(X++ * ++X); // 120 (10 * 12)
X = 10; System.out.println(++X * X++); // 121 (11 * 11)

第一行看起来像

X++       * ++X
10 (X=11) * (X=12) 12
10        * 12 = 120

第二个

++X       * X++
(X=11) 11 * 11 (X=12)
11        * 11 = 121

---

那么为什么表中有前缀和后缀的自增/自减运算符呢？

确实，在乘法之前必须执行递增和递减。但这句话的意思是：

Y = A * B++

// Should be interpreted as
Y = A * (B++)

// and not
Y = (A * B)++

就像

Y = A + B * C

// Should be interpreted as
Y = A + (B * C)

// and not
Y = (A + B) * C

操作数求值的顺序仍然是从左到右。

---

如果你还没有被说服：

考虑以下程序：

class Test
{
    public static int a(){ System.out.println("a"); return 2; }
    public static int b(){ System.out.println("b"); return 3; }
    public static int c(){ System.out.println("c"); return 4; }

    public static void main(String[] args)
    {
        System.out.println(a() + b() * c());
        // Lets make it even more explicit
        System.out.println(a() + (b() * c()));
    }
}

如果参数在需要时求值，b 或 c 将首先出现，然后是另一个，最后是 a。但是，程序输出：

一种 b C 14 一种 b C 14

因为，无论等式中需要和使用它们的顺序如何，它们仍然求值从左到右。

有用的阅读：

• What are the rules for evaluation order in Java?
• a += a++ * a++ * a++ in Java. How does it get evaluated?
• Appendix A: Operator Precedence in Java

Answer 2

总之，

优先级就像准备要通过括号计算的表达式。接下来从左到右进行评估，将每对括号视为单独的操作。

例如，如果i=2 则i+i++ 在优先级之后变为i+(i++) 并计算为2+2 = 4。 但是，i+++i 变为 (i++)+i 并计算为 2+3 = 5。

与i+(i=5) 相同，计算结果为2+5 = 7。

事实上，后缀运算符的优先级确实高于前缀运算符。例如，i+++++i 在优先级之后变为((i++)++)+i，这会导致编译错误（第二个后缀运算符需要一个变量来操作，但找到了一个值！）。如果后缀和前缀运算符的优先级相同，则表达式将变为 (i++)+(++i) 并计算为 2+4 = 6。

如果您需要更多解释，可以编译并运行以下代码并检查输出中打印的示例。

public class TestPrecedence {
    public static void main(String[] str) {
        int i = 0;
        System.out.println("\n");
        i = 2; System.out.println("i = " + i + "\n");
        i = 2; System.out.println("i++ = " + i++ + "\n");
        i = 2; System.out.println("++i = " + ++i + "\n");
        i = 2; System.out.println("i++i = (i++)i TestPrecedence.java:8: error: ')' expected\n"+
                                  "              i++i\n"+
                                  "                 ^\n");
        i = 2; System.out.println("i+-i = i+(-i) = " + (i+-i) + "\n");
        i = 2; System.out.println("++i++ = ++(i++) TestPrecedence.java:12: error: unexpected type\n"+
                                  "                ++i++ \n"+
                                  "                   ^\n"+
                                  "                required: variable\n"+
                                  "                found:    value\n");
        i = 2; System.out.println("i+++++i = ((i++)++)+i TestPrecedence.java:17: error: unexpected type\n"+
                                  "                      i+++++i\n"+
                                  "                       ^\n"+
                                  "                      required: variable\n"+
                                  "                      found:    value\n");
        i = 2; System.out.println("i++ + ++i = " + (i++ + ++i) + "\n");
        i = 2; System.out.println("i+(i=3) = " + (i+(i=3)) + " evaluates left to right\n");
        i = 2; System.out.println("i+i++ precedence yields i+(i++) evaluates to 2+2 = " + (i+i++) + "\n");
        i = 2; System.out.println("i+++i precedence yields (i++)+i evaluates to 2+3 = " + (i+++i) + "\n");
        System.out.println("\n");
    }
}

Answer 3

它的1440之所以是因为

1. x 设置为 10，即第一项是固定的（整体方程 10 *）

2. x 增加 1,x =11 现在

3. x 预先增加 1 x=12，第二项现在是 FIXED（整体方程 10 * 12 *）

4. 现在 x 设置为 12，第三项 FIXED（整体方程 10 * 12 *12）

5. x 现在是递增的，但在这种情况下不用于评估，

简而言之，当变量发生时是固定的，在这种情况下是 X

第二种情况： 我不确定，但我想可能会被打破，

1. a=b+a
2. a++

我认为这是正在发生的事情。

Answer 4

第二个 ->

int a=1, b=2;             
a += b + a++;

编译器会将其转换为

 a = a + b + a++;

然后应用你的逻辑，你会发现 a 是 4 的原因。

Answer 5

第一步

1) first postfix operator: X++ 
   1.a) X++ "replaced" by 10
   1.b) X incremented by one: 10+1=11
   At this step it should look like:  System.out.println(10 * ++X * X++), X = 11;

2) prefix operator: ++X
   2.a) X "replaced" by 11
   2.b) X incremented by one: 11+1=12
   At this step it should look like:  System.out.println(10 * 12 * X++), X = 12;

3) second POSTfix operator: X++
   3.a) X "replaced" by 12
   3.b) X incremented by one: 12+1=13
   At this step it should look like:  System.out.println(10 * 12 * 12),  X = 13;

这打印10 * 12 * 12 = 1440

这是第一步的字节码

 1. bipush 10
 2. istore_0
 3. getstatic java/lang/System/out Ljava/io/PrintStream;
 4. iload_0
 5. iinc 0 1
 6. iinc 0 1
 7. iload_0
 8. imul
 9. iload_0
10. iinc 0 1
11. imul
12. invokevirtual java/io/PrintStream/println(I)V
13. return

执行以下操作：

 1. Push 10 to the stack
 2. Pop 10 from the stack to X variable
 3. Push X variable value (10) to the stack
 5. Increment local variable X (11)
 6. Increment local variable X (12)
 7. Push X variable value (12) to the stack
 8. Multiply top and subtop (10*12) Now Top = 120 
 9. Push X variable value (12) to the stack
10. Increment local variable X (13)
11. Multiply top and subtop (120*12) Now Top = 1440

注意最后一个增量（10.）是在将 X 推入堆栈之后完成的