java中间变量缓存机制——i=i++;

首先我们来看这样一个有意思的java程序：

public static void main(String[] args){
     int i, sum1, sum2;
     
     i=0;
     sum1 = (i++)+(i++);
     System.out.println("sum1="+sum1);
     
     i = 0;
     sum2 = (++i)+(++i);
     System.out.println("sum2="+sum2);	 
}

程序的运行结果是：sum1=1      sum2=3

为什么会出现这样的结果呢？这和java的中间变量缓存机制有关。

        在java中，执行自增运算时，会为每一个自增操作分配一个临时变量，如果是前缀加（++i），就会“先自加1后赋值（给临时变量）”；如果是后缀加(i++)，就会“先赋值（给临时变量）后自加1”。运算最终使用的，并不是变量本身，而是被赋了值的临时变量。

        所以上例执行sum1=(i++)+(i++)时，创建了2个临时的整型变量对象来存储每次自增运算的结果，最后再使用临时变量进行运算。执行这句代码等效于执行以下代码：

    temp1 = i;           //i=0,temp1=0
    i = i + 1;           //i=1
    temp2 = i;           //i=1,temp2=1
    i = i + 1;           //i=2
    sum = temp1 + temp2  //sum=1

        

上面的例子看完了，关于自增运算再来个系统一点的示例程序吧：

public class Test {  
 public static void main(String[] args) {  
 
  int i = 10;  
  int a = 0;  
  int b = 0;  
  int c = 0;  
  int d = 0;  
  
  a = i++ + i++; //a=21，等效执行以下程序
  /*  
   * temp1 = i;        //i=10,temp=10 
   * i = i + 1;        //i=11  
   * temp2 = i;        //a=11,temp2=11 
   * i = i + 1;        //i=12  
   * a = temp1 + temp2 //a=21;  
   */  
  
  b = ++i + ++i;  //b=23  
  /*  
   * i = i + 1;        //i=11  
   * temp1 = i;        //i=11 , temp=11
   * i = i + 1;        //i=12  
   * temp2 = i;        //i=12.temp=12
   * b = temp1 + temp2 //b=23;  
   */  
  
  c = ++i + i++; //b=22  
  /*  
   * i = i + 1;        //i=11  
   * temp1 = i;        //i=11,temp=11  
   * temp2 = i         //i=11,temp=11  
   * i = i + 1;        //i=12   
   * c = temp1 + temp2 //c=22  
   */  
  
  
  d = i++ + ++i; //22  
  /*  
   * temp1 = i;        //i=10,temp=10
   * i = i + 1;        //i=11  
   * i = i + 1;        //i=12  
   * temp2 = i;        //i=12,temp2=12  
   * d = temp1 + temp2 //d=22;  
   */  
  
  System.out.println(a);  
  System.out.println(b);  
  System.out.println(c);  
  System.out.println(d);  
 }  
}  

再看程序员面试宝典中一个很经典的例子：

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

程序的运行结果是：0

看完java，再来看看同样是自增操作C语言里面结果会如何：

void main()    
{  
    int i,sum1,sum2;  
  
    i=0;  
    sum1=(i++)+(i++);  
    printf("sum1=%d\n",sum1);  
  
    i=0;  
    sum2=(++i)+(++i);  
    printf("sum2=%d\n",sum2);  
  
    getchar();  
}  

程序的运行结果是：sum1=0   sum2=4

这次又是怎么回事呢？

        在c语言中，每个变量在它的生命周期内（此例就是整个main函数里）的每个时间点都只能有一个唯一的值。因此变量在每一次自增运算生效时，变量所对应内存区域的内容就被重写了。和java最终使用临时变量不同，C最终使用的是变量本身。

        此例中，sum1在加法运算执行之前，左边的i初始为0，++操作此时未生效，所以i还是等于0，右边的i（和左边的是同一块内存空间）自然初始值也为0，这个++操作此时也未生效，取出i值进行相加后，前后两次++操作才生效，最后sum1=0,i=2。

        而sum2在加法运算执行之前，左边的i初始为0，++操作此时生效，所以i等于1，右边的i（和左边的是同一块内存空间）自然初始值也为1，这个++操作此时也生效，所以i=2，取出i值（2）进行相加后，sum1=4。注意这里左右两边加的是同一块内存空间。

写在最后：这个问题本来我也不清楚，是观看了另外两个博主的博客后才豁然开朗的。但这两篇各有优点，同时自感表达不够详细，所以按照自己的理解写了一篇。原文链接：

1. http://blog.csdn.net/zlqqhs/article/details/8288800

2. http://blog.csdn.net/maggiedorami/article/details/7986098