这是因为在这种情况下它永远不会增加。x++会先使用它的值，然后再进行递增，在这种情况下，它会像这样:

x = 0;

但如果你用++x;这将会增加。

x++表达式求值为x。++部分影响求值之后的值，而不是语句之后的值。所以x = x++可以有效地转换成

int y = x; // evaluation
x = x + 1; // increment part
x = y; // assignment

Note: Originally I posted C# code in this answer for purposes of illustration, since C# allows you to pass int parameters by reference with the ref keyword. I've decided to update it with actual legal Java code using the first MutableInt class I found on Google to sort of approximate what ref does in C#. I can't really tell if that helps or hurts the answer. I will say that I personally haven't done all that much Java development; so for all I know there could be much more idiomatic ways to illustrate this point.

也许如果我们写一个方法来做x++所做的事情，就会更清楚。

public MutableInt postIncrement(MutableInt x) {
    int valueBeforeIncrement = x.intValue();
    x.add(1);
    return new MutableInt(valueBeforeIncrement);
}

对吧?对传递的值加1并返回原始值:这就是后加1操作符的定义。

现在，让我们看看这个行为是如何在你的示例代码中发挥作用的:

MutableInt x = new MutableInt();
x = postIncrement(x);

postIncrement(x)做什么?增量x，对。然后返回x在增量之前的值。然后这个返回值被赋值给x。

所以x的值的顺序是0，然后是1，然后是0。

如果我们重写上面的代码，这可能会更清楚:

MutableInt x = new MutableInt();    // x is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
x = temp;                           // Now x is 0 again.

当你把上面赋值的左边的x替换为y时，“你可以看到它首先增加了x，然后把它归为y”，这让我很困惑。不是x被赋值给y;它是以前赋给x的值。实际上，注入y与上面的场景没有什么不同;我们得到:

MutableInt x = new MutableInt();    // x is 0.
MutableInt y = new MutableInt();    // y is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
y = temp;                           // y is still 0.

很明显，x = x++不会改变x的值，它总是使x的值为x0，然后是x0 + 1，然后又是x0。

更新:顺便说一句，为了避免您怀疑x在增量操作和上面示例中的赋值之间被赋值为1，我已经组合了一个快速演示来说明这个中间值确实“存在”，尽管它永远不会在执行线程上“看到”。

演示调用x = x++;在循环中，另一个线程连续地将x的值打印到控制台。

public class Main {
    public static volatile int x = 0;

    public static void main(String[] args) {
        LoopingThread t = new LoopingThread();
        System.out.println("Starting background thread...");
        t.start();

        while (true) {
            x = x++;
        }
    }
}

class LoopingThread extends Thread {
    public @Override void run() {
        while (true) {
            System.out.println(Main.x);
        }
    }
}

下面是上述程序输出的摘录。注意1和0的不规则出现。

Starting background thread...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

检查下面的代码，

    int x=0;
    int temp=x++;
    System.out.println("temp = "+temp);
    x = temp;
    System.out.println("x = "+x);

输出将是，

temp = 0
x = 0

后增量是指将值递增，并返回该增量之前的值。这就是temp值为0的原因。那么如果temp = i并且这是在一个循环中(除了第一行代码)。就像问题!!!!一样

X = x++的工作方式如下:

首先，它计算表达式x++。对该表达式求值产生一个表达式值(即x在递增前的值)，并使x递增。 之后，它将表达式值赋给x，覆盖增量值。

因此，事件的序列如下所示(这是一个实际的反编译字节码，由javap -c生成，带有我的注释):

   8:   iload_1         // Remember current value of x in the stack
   9:   iinc    1, 1    // Increment x (doesn't change the stack)
   12:  istore_1        // Write remebered value from the stack to x

作为比较，x = ++x:

   8:   iinc    1, 1    // Increment x
   11:  iload_1         // Push value of x onto stack
   12:  istore_1        // Pop value from the stack to x

这是因为在这种情况下它永远不会增加。x++会先使用它的值，然后再进行递增，在这种情况下，它会像这样:

x = 0;

但如果你用++x;这将会增加。