Java：pre-postfix运算符优先级
关于Java中的运算符优先级，我有两个类似的问题。
第一：
int X = 10; System.out.println(X++ * ++X * X++); //it prints 1440 根据Oracle教程 ：
postfix（expr ++，expr–）运算符的优先级高于prefix（++ 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。
第二个：
这个问题的例子：
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
我真的很困惑。 我已经花了几个小时但仍然无法理解我错在哪里。
PS我知道，我不应该在实际应用中使用这种“风格”。 我只想了解我的想法有什么问题。
混淆源于操作数从左到右评估的事实。 在对操作员优先级/操作顺序给予任何关注之前，首先完成此操作 。
此行为在JLS 15.7.2中指定。 在操作之前评估操作数
所以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
因为，无论它们在等式中需要和使用的顺序如何，它们仍然从左到右进行评估 。
有用的阅读：
- Java中评估顺序的规则是什么？
- Java中的a + = a ++ * a ++ * a ++。 如何评估？
- 附录A：Java中的运算符优先级
之所以1440是因为
-
x设置为10，即第一项为FIXED（整体等式10 *）
-
x现在增加1，x = 11
-
x现在预先递增1 x = 12和第二项FIXED（整体等式10 * 12 *）
-
现在x设置为12，第三项设置为FIXED（整体等式10 * 12 * 12）
-
x现在是增量，但在这种情况下不用于评估，
简而言之，当变量出现时，术语是固定的，在这种情况下是X.
第二种情况：我不确定，但我想可以打破，
-
a=b+a -
a++
我认为正在发生的事情。
简而言之，
优先级就像准备通过括号括起来计算表达式。 考虑每对括号作为单独的操作，从左到右进行评估。
例如，如果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"); } }
对于第二个 – >
int a=1, b=2; a += b + a++;
编译器会将其转换为
a = a + b + a++;
然后应用你的逻辑，你会发现a为4的原因。
第一步
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
注意，在将X推入堆栈之后，完成最后一次增量（10.）