我有以下代码:

public class Tests {
    public static void main(String[] args) throws Exception {
        int x = 0;
        while(x<3) {
            x = x++;
            System.out.println(x);
        }
    }
}

我们知道他应该只写x++或x=x+1,但在x=x+ +时,它应该先把x归为自己,然后再加1。为什么x的值是0 ?

- - -更新

下面是字节码:

public class Tests extends java.lang.Object{
public Tests();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   iconst_3
   4:   if_icmpge   22
   7:   iload_1
   8:   iinc    1, 1
   11:  istore_1
   12:  getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  iload_1
   16:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   19:  goto    2
   22:  return

}

我会仔细阅读说明,试着理解……


当前回答

把x++看作是一个函数调用,它“返回”x在增量之前的值(这就是为什么它被称为后增量)。

所以运算顺序为: 1:缓存x的值 2:增量x 3:返回缓存的值(x在它被增加之前) 4:将返回值赋给x

其他回答

据我所知,错误发生了,由于赋值覆盖了增量值,在增量之前的值,即它取消了增量。

具体来说,"x++"表达式在递增前的值为'x',而"++x"表达式在递增后的值为'x'。

如果你对研究字节码感兴趣,我们将看一下有问题的三行:

 7:   iload_1
 8:   iinc    1, 1
11:  istore_1

7: iload_1 #将第二个本地变量的值放在堆栈上 8: iinc 1,1 #将使第二个局部变量加1,注意它不影响堆栈! 9: istore_1 #将弹出堆栈顶部,并将该元素的值保存到第二个局部变量中 (你可以在这里阅读每条JVM指令的效果)

这就是为什么上面的代码将无限循环,而带有++x的版本不会。 ++x的字节码应该看起来很不一样,据我所知,在我一年多以前写的1.3 Java编译器中,字节码应该是这样的:

iinc 1,1
iload_1
istore_1

所以只是交换了前两行,改变了语义,使得留在堆栈顶部的值,在增量之后(即表达式的“值”)是增量之后的值。

没有一个答案是完全正确的,所以是这样的:

当你写int x = x++时,你不是把x赋值为它自己的新值,你是把x赋值为x++表达式的返回值。也就是x的原始值,正如Colin Cochrane的答案所暗示的那样。

为了好玩,测试下面的代码:

public class Autoincrement {
        public static void main(String[] args) {
                int x = 0;
                System.out.println(x++);
                System.out.println(x);
        }
}

结果将是

0
1

表达式的返回值是x的初始值,即0。但是稍后,当读取x的值时,我们会收到更新后的值,即1。

你有效地得到了以下行为。

获取x的值(它是0)作为右边的“结果” 增加x的值(x现在是1) 将右边的结果(保存为0)分配给x (x现在是0)

其思想是,后增量操作符(x++)在返回变量的值后对该变量进行增量,以便在使用该变量的方程中使用。

编辑:由于评论的原因,稍微增加了一点。像下面这样考虑。

x = 1;        // x == 1
x = x++ * 5;
              // First, the right hand side of the equation is evaluated.
  ==>  x = 1 * 5;    
              // x == 2 at this point, as it "gave" the equation its value of 1
              // and then gets incremented by 1 to 2.
  ==>  x = 5;
              // And then that RightHandSide value is assigned to 
              // the LeftHandSide variable, leaving x with the value of 5.

这是因为它是后增量的。它意味着变量在表达式求值之后递增。

int x = 9;
int y = x++;

X现在是10,但y是9,这是X加之前的值。

更多信息请参见后增量的定义。

我想知道Java规范中是否有精确定义此行为的内容。(这句话的明显意思是我懒得去检查。)

注意Tom的字节码,关键行是7、8和11。第7行将x加载到计算堆栈中。第8行增加x。第11行将堆栈的值存储回x。在正常情况下,如果你不将值赋值回自身,我不认为有任何理由不能加载,存储,然后增加。你会得到同样的结果。

比如,假设你有一个更正常的情况,你写这样的东西: z = (x + +) + (y + +);

它是否说(跳过技术细节的伪代码)

load x
increment x
add y
increment y
store x+y to z

or

load x
add y
store x+y to z
increment x
increment y

应该无关紧要。我认为,任何一种实现都是有效的。

我会非常谨慎地编写依赖于这种行为的代码。对我来说,它看起来非常依赖于实现。只有当您做了一些疯狂的事情(比如这里的例子),或者您有两个线程正在运行,并且依赖于表达式中的求值顺序时,才会产生影响。