Java中的自增问题（i=i++）

　　也许我这是在较真， 但是我们确实有时候就不小心就错写为这种情况了。

看如下代码：

public class Test{

        public static void main(String[] args){
                int a = 3;
                int b = 5;
                a = a++;
                b = ++b;
        }

}

　　这时候， 如果输出 a 和 b ，那么 他们的值是什么？ 答案是 a = 3; b = 6;

　　如果你感到迷惑， 那么继续往下看， 如果你知道其中的原理，那么就不用看了。

我们利用 jdk 自带的两个命令（javac，javap）来看看 JVM 虚拟机到底在底层做了些什么。

建立一个文件 Test.java 并把上面的代码写入其中， 然后里用 javac 命令编译

wuqinglong@debian:~$ javac -g:vars Test.java

　　然后利用 javap 命令查看 JVM 编译之后的虚拟机指令。

wuqinglong@debian:~$ javap -verbose Test

　　输出如下内容

Classfile /home/wuqinglong/Test.class
  Last modified 2016-3-16; size 326 bytes
  MD5 checksum 2e2f3ec62c26d0e1e53bb121e83b9032
public class Test
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #3.#17         // java/lang/Object."<init>":()V
   #2 = Class              #18            // Test
   #3 = Class              #19            // java/lang/Object
   #4 = Utf8               <init>
   #5 = Utf8               ()V
   #6 = Utf8               Code
   #7 = Utf8               LocalVariableTable
   #8 = Utf8               this
   #9 = Utf8               LTest;
  #10 = Utf8               main
  #11 = Utf8               ([Ljava/lang/String;)V
  #12 = Utf8               args
  #13 = Utf8               [Ljava/lang/String;
  #14 = Utf8               a
  #15 = Utf8               I
  #16 = Utf8               b
  #17 = NameAndType        #4:#5          // "<init>":()V
  #18 = Utf8               Test
  #19 = Utf8               java/lang/Object
{
  public Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=1
         0: iconst_3    // 将int类型的3送到栈顶
         1: istore_1    // 将栈顶的int类型的值存储到slot为1的int类型的本地变量中，slot编号对应的变量名在后三行。
         2: iconst_5    // 将int类型的5送到栈顶
         3: istore_2    // 将栈顶的int类型的值存储到slot为2的int类型的本地变量中
         4: iload_1    // 将slot为1的int类型的本地变量加载到栈顶
         5: iinc          1, 1    // 将slot为1的本地int类型的变量的值加1
         8: istore_1    // 将栈顶的int类型的值存储到slot为1的本地变量中
         9: iinc          2, 1    // 将slot为2的本地intbeijing的变量的值加1
        12: iload_2    // 将slot为2的int类型的本地变量加载到栈顶
        13: istore_2    // 将栈顶的int类型的值存储到slot为2的int类型的本地变量中
        14: return    // 结束
      LocalVariableTable:    // 变量对应的slot编号如下
        Start  Length  Slot  Name   Signature
            0      15     0  args   [Ljava/lang/String;
            2      13     1     a   I
            4      11     2     b   I
}

　　如果有点汇编知识的话，看上面的代码会比较好理解点， 如果没有学过汇编指令的话， 就看注释。

其中最主要的区别是：

　　对于  a = a++;  JVM 进行的操作是：

　　　　1. 将本地变量的值加载到栈顶  (注意： 这时候这个值是没有经过自增操作的)

　　　　2. 对本地变量的值进行自增（对栈顶对象没有影响）

　　　　3. 把栈顶变量的值存储到本地变量中（重新对本地变量赋值，栈顶变量的值并没有进行自增操作，自增操作是对本地变量进行操作的）

　　对于  b = ++b;  JVM 进行的操作是：

　　　　1. 将本地变量的值先自增

　　　　2. 将自增完之后的本地变量的值加载到栈顶（注意：这时候这个值是经过了自增操作的）

　　　　3. 将栈顶变量的值存储到本地变量中