Java篇——运算顺序的详细挖掘

yujianta14

在 Java 运算中，存在一些关系到顺序的计算，这些计算顺序在 C / C++语言中是不确定的，并且最后的结果值也没有保证。不过， Java 经过编译之后，生成的是与平台无关的字节码，并且交互对象为 Java 虚拟机，与底层的硬件环境无关。因此，这些运算结果在 Java 中是确定的。
从左向右的计算顺序
与 C / C++不同的是，在 Java 中，表达式的计算与结果是确定的。不受硬件环境的影响。例如，一个在 C / C++中比较常见例子：

1. int i = 5;
   
2. int j = (i++) + (i++) + (i++);

复制代码

在 C / C++中，变量 i 与 j 的值是不确定的，根据不同的开发环境，结果也不相同。例如，在 Turbo C 中， i 的值为 8， j 的值为 15，而在 VC 中， i 的值为 8， j 的值为 18。在 Java中， i和 j 的值是确定的， i 为 8， j 为 18。
在 Java 中，操作数的计算顺序是从左向右的也就是首先会计算左侧的操作数，然后再计算其右侧的操作数。例如：

1. int a = 3;
   
2. int b = a + (++a) + (a = 1) + a;

复制代码

执行这两个语句之后， a 的值为 1， b 的值为 9。因为 Java 就是从左向右进行计算的，故最后（即最右侧）一条修改 a 值的表达式为：

1. 
   
2. a = 1

复制代码

而第 2 条语句也就是：

1. int b = 3 + 4 + 1 + 1;

复制代码

操作数从左向右的计算规则与运算符的结合性无关，就算运算符是由右向左结合的，也会在运算之前先确定左侧的操作数，请看下面的程序。
【例】 操作数的确定。

1. 1.package chapter2;
   
2. 2.
   
3. 3. import java.util.Arrays;
   
4. 4.
   
5. 5. public class Order {
   
6. 6. public static void main(String[] args) {
   
7. 7. int a[] = new int[] {
   
8. 8. 0, 0, 0, 0, 0, 0
   
9. 9. };
   
10. 10. int i = 1;
    
11. 11. a[++i] = i++;
    
12. 12. System.out.println("i=" + i);
    
13. 13. System.out.println(Arrays.toString(a));
    
14. 14. int j = 3;
    
15. 15. a[j] = j = 4;
    
16. 16. System.out.println("j=" + j);
    
17. 17. System.out.println(Arrays.toString(a));
    
18. 18. int b[] = new int[] {
    
19. 19. 9, 9, 9, 9, 9, 9
    
20. 20. };
    
21. 21. int k = 5;
    
22. 22. int c[] = a;
    
23. 23. a[--k] = (a = b)[k];
    
24. 24. System.out.println("k=" + k);
    
25. 25. System.out.println(Arrays.toString(a));
    
26. 26. System.out.println(Arrays.toString(b));
    
27. 27. System.out.println(Arrays.toString(c));
    
28. 28. }
    
29. 29.}

复制代码

程序运行结果如下：

1. i=3
   
2. [0, 0, 2, 0, 0, 0]
   
3. j=4
   
4. [0, 0, 2, 4, 0, 0]
   
5. k=4
   
6. [9, 9, 9, 9, 9, 9]
   
7. [9, 9, 9, 9, 9, 9]
   
8. [0, 0, 2, 4, 9, 0]

复制代码

你预测正确了吗？对于程序第 11 行：

1. a[++i] = i++;

复制代码

虽然赋值运算符是从右向左结合的，但是操作数的确定是从左向右的，也就是在赋值操作发生前，首先会确定左侧的操作数， i 的值为 1， ++i 的值就是 2，因此，左侧的操作数是 a[2]，因此，这条语句就相当于：

1. a[2] = 2;

复制代码

然后 i 的值再加 1，值为 3。
第 15 行的赋值语句：

1. a[j] = j = 4;

复制代码

也是同样的道理，首先确定左侧操作数， j 的值为 3，也就是 a[3]，这相当于：

1. a[3] = j = 4;

复制代码

赋值之后， j 和 a[3]的值都是 4。
同样，第 23 行的语句：

1. a[--k] = (a = b)[k];

复制代码

k 的值是 5，这就相当于：

1. --k;
   
2. int[] temp = a;
   
3. a = b;
   
4. temp[4] = b[4];

复制代码

然后，原数组 a[4]（也就是后来的 c[4]）的值改变。