Java的中间缓存变量机制与自增操作符

本文主要是介绍Java的中间缓存变量机制与自增操作符，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一大早起来，本想做个小题练练手，没想到居然被难住了！！先把题目贴上，各位先做做看：

求输出结果

1.public static void main(String[] args){
int j=0;
for (int i = 0; i < 100; i++) {
j = j++;
}
System.out.println(j);

2.

1. public static void main(String[] args){  
2.      int i, sum1, sum2;  
3.        
4.      i=0;  
5.      sum1 = (i++)+(i++);  
6.      System.out.println("sum1="+sum1);  
7.        
8.      i = 0;  
9.      sum2 = (++i)+(++i);  
10.      System.out.println("sum2="+sum2);     
11. }  

/*******答案在页尾不许偷看******答案在页尾不许偷看*****答案在页尾不许偷看******答案在页尾不许偷看************/

在涉及到自增、增减符时，需要着重注意，在计算的过程中，java使用了中间变量缓冲机制。

在java中，执行自增、自减运算时，系统会为每个自增操作分配一个临时变量。如果是前缀(++i)，就会【先自加1再赋值给临时变量】；如果是后缀(i++)，就会【先赋值给临时变量再自加1】。运算最终使用的，不是变量本身，而是被赋值后的临时变量，注意了！！

比如说第一题中循环中的 j = j++; 操作，其实等价于：

   temp = j ; //先赋值

   j = j + 1; //再加一

   j = temp; //最终使用的是 临时变量

所以可以知道输出结果为： 0

第二题中

i=0;

sum1 = (i++) +(i++);

和题一相同，i先赋值给临时变量temp，然后i自增为1，此时第二个自增中i已经为1了，注意！

还是先赋值给临时变量2 temp2，然后自增；

最后sum1 等于 temp + temp2 ，结果为 1 。

i = 0;

sum2 = (++i) + (++i);

第一个 ++i 先自增为1，并赋值给临时变量temp，此时i为1， 第二个 ++ i 自增为2，赋值给临时变量2 temp2

所以sum2 等于 第一个临时变量temp + 第二个临时变量temp2，结果为3.

一个不会的题牵引出了一个自己的漏洞，还好及时填补。开始我还在想是不是运算符优先级的问题？

看来对于运算符优先级也不是很清楚，在此贴上一张运算符优先级表，与君共勉。

1. 优先级   操作符   含义        关联性  用法   
2. ----------------------------------------------------------------  
3. 1        [ ]      数组下标      左    array_name[expr]   
4.          .        成员选择      左    object.member   
5.          ( )      方法参数      左    method_name(expr_list)   
6.          ( )      实例构造      左    class_name(expr_list)   
7.          ++       后缀自增      左    lvalue++   
8.          --       后缀自减      左    lvalue--   
9.   
10. 2        ++       前缀自增      右    ++rvalue   
11.          --       前缀自减      右    --lvalue   
12.          ~        按位取反      右    ~expr   
13.          !        逻辑非        右    !expr   
14.          +        一元加        右    +expr   
15.          -        一元减        右    -expr   
16.   
17. 3        ( )      强制转换      右    (type)expr   
18.          new      对象实例化    右    new type()   
19.                                       new type(expr_list)   
20.                                       new type[expr]   
21.   
22. 4        *        乘            左    expr * expr   
23.          /        除            左    expr / expr   
24.          %        求余          左    expr % expr   
25.   
26. 5        +        加            左    expr + expr   
27.          -        减            左    expr - expr   
28.          +        字符串连接    左    strExpr + strExpr   
29.   
30. 6        >>       有符号右移    左    expr >> distance   
31.          >>>      无符号右移    左    expr >>> distance   
32.   
33. 7        <        小于          左    expr < expr   
34.          <=       小于等于      左    expr <= expr   
35.          >        大于          左    expr > expr   
36.          >=       大于等于      左    expr >= expr   
37.       instanceof  类型比较      左    ref instanceof refType   
38.          ==       等于          左    expr == expr   
39.          !=       不等于        左    expr != expr   
40.   
41. 8        &        整数按位与    左    integralExpr & integralExpr   
42.          &        布尔与        左    booleanExpr & booleanExpr   
43.   
44. 9        ^        整数按位异或  左    integralExpr ^ integralExpr   
45.          ^        布尔异或      左    booleanExpr ^ booleanExpr   
46.   
47. 10       |        整数按位或    左    integralExpr | integralExpr   
48.          |        布尔或        左    booleanExpr | booleanExpr   
49.   
50. 11       &&       逻辑与        左    booleanExpr && booleanExpr   
51.   
52. 12       ||       逻辑或        左    booleanExpr || booleanExpr   
53.   
54. 13       ? :      条件运算      右    booleanExpr ? expr : expr   
55.   
56. 14       =        赋值          右    lvalue = expr   
57.          *=       乘赋值        右    lvalue *= expr   
58.          /=       除赋值        右    lvalue /= expr   
59.          %=       模赋值        右    lvalue %= expr   
60.          +=       加赋值        右    lvalue += expr   
61.          +=    字符串连接赋值   右    lvalue += expr   
62.          -=       减赋值        右    lvalue -= expr   
63.          <<=      左移赋值      右    lvalue <<= expr   
64.          >>=   有符号右移赋值   右    lvalue >>= expr   
65.          >>>=  无符号右移赋值   右    lvalue >>>= expr   
66.          &=    整数按位与赋值   右    lvalue &= expr   
67.          &=       布尔与赋值    右    lvalue &= expr   
68.          |=    整数按位或赋值   右    lvalue |= expr   
69.          |=       布尔或赋值    右    lvalue |= expr   
70.          ^=   整数按位异或赋值  右    lvalue ^= expr   
71.          ^=     布尔异或赋值    右    lvalue ^= expr  

这篇关于Java的中间缓存变量机制与自增操作符的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---