为什么这会陷入无限循环？

我有以下代码：

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

我们知道他应该已经写了just x++或x=x+1，但是x = x++首先应该将属性写给x自己，然后再递增。为什么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

}

我将阅读说明以尝试理解...

注意：最初出于说明目的，我在此答案中发布了C＃代码，因为C＃允许您通过int带有ref关键字的引用来传递参数。我决定使用MutableInt我在Google上找到的第一个类，使用实际的合法Java代码对其进行更新，以近似于refC＃的功能。我真的不能说这是帮助还是伤害答案。我会说我个人没有做太多的Java开发工作。因此，据我所知，可能会有更多惯用的方式来说明这一点。

也许如果我们写出一种方法来做与之等效的事情x++，这将使事情变得更清楚。

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

对？递增传递的值并返回原始值：这是postincrement运算符的定义。

现在，让我们看看这种行为在示例代码中如何发挥作用：

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具有值x ₀，然后是x ₀ +1，然后又是x ₀。

更新：顺便说一句，为了避免您怀疑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的不规则出现。

正在启动后台线程...
0
0
1个
1个
0
0
0
0
0
0
0
0
0
0
1个
0
1个

x = x++ 以下列方式工作：

• 首先，它评估表达式x++。对该表达式求值会生成一个表达式值（即x递增之前的值）和增量x。
• 之后，它将表达式值分配给x，覆盖增量值。

因此，事件的顺序如下所示（这是实际的反编译字节码，由产生javap -c，带有我的评论）：

   8：iload_1 //记住堆栈中x的当前值
   9：iinc 1、1 //递增x（不更改堆栈）
   12：istore_1 //将重新生成的值从堆栈写入x

为了进行比较，x = ++x：

   8：iinc 1、1 //递增x
   11：iload_1 //将x的值压入堆栈
   12：istore_1 //将值从堆栈弹出到x

发生这种情况是因为的值x根本没有增加。

x = x++;

相当于

int temp = x;
x++;
x = temp;

说明：

让我们看一下该操作的字节码。考虑一个示例类：

class test {
    public static void main(String[] args) {
        int i=0;
        i=i++;
    }
}

现在，在此上运行类反汇编程序，我们得到：

$ javap -c test
Compiled from "test.java"
class test extends java.lang.Object{
test();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_0
   1:    istore_1
   2:    iload_1
   3:    iinc    1, 1
   6:    istore_1
   7:    return
}

现在，Java VM是基于堆栈的，这意味着对于每个操作，数据将被压入堆栈，而数据将从堆栈中弹出以执行操作。还有另一种数据结构，通常是用于存储局部变量的数组。局部变量被赋予id，它们只是数组的索引。

让我们来看看助记符中main()方法：

• iconst_0：将常量值0 压入堆栈。
• istore_1：弹出堆栈的顶部元素，并将其存储在索引1
  为的局部变量 中x。
• iload_1：在该位置处的值1是值的x 是0，被压入堆栈。
• iinc 1, 1：存储位置的1值增加1。所以x现在变成了 1。
• istore_1：堆栈顶部的值存储到存储位置1。这是0被分配到x 覆盖其增加后的值。

因此，的值x不会改变，从而导致无限循环。

1. 在计算表达式之前，前缀符号将使变量递增。
2. 后缀表示法将在表达式求值后增加。

但是，“ =”的运算符优先级低于“ ++”。

所以x=x++;应该评价如下

1. x 准备分配（评估）
2. x 递增的
3. x分配给的先前值x。

没有一个答案很明显，所以去了：

在编写时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

表达式的返回值是的初始值为x0。但是稍后，当读取的值时x，我们将收到更新后的值，即为1。

其他人已经对此进行了很好的解释。我只包含指向相关Java规范部分的链接。

x = x ++是一个表达式。Java将遵循评估顺序。它将首先计算表达式x ++，该表达式将使x递增并将结果值设置为x的先前值。然后它将表达式结果分配给变量x。最后，x返回其先前的值。

这个说法：

x = x++;

评估如下：

1. 推x入堆栈；
2. 增量x;
3. x从堆栈中弹出。

因此该值不变。比较一下：

x = ++x;

其评估为：

1. 增量x;
2. 推x入堆栈；
3. x从堆栈中弹出。

您想要的是：

while (x < 3) {
  x++;
  System.out.println(x);
}

答案很简单。它与事物评估的顺序有关。x++返回值，x然后递增x。

因此，表达式的x++值为0。因此，您要x=0在循环中分配每次。当然会x++增加该值，但这在分配之前发生。

从http://download.oracle.com/javase/tutorial/java/nutsandbolts/op1.html

可以在操作数（前缀）之前或之后（后缀）应用增量/减量运算符。代码结果++; 和++结果；都将导致结果加一。唯一的区别是前缀版本（++ result）的值等于增量值，而后缀版本（result ++）的值等于原始值。如果您只是执行简单的增量/减量，则选择哪个版本都没有关系。但是，如果在较大表达式的一部分中使用此运算符，则选择的运算符可能会产生很大的不同。

为了说明，请尝试以下操作：

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

它将打印1和0。

您实际上得到了以下行为。

1. 抓取x的值（为0）作为右侧的“结果”
2. 增加x的值（所以x现在为1）
3. 将右侧的结果（保存为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.

您实际上并不需要机器代码来了解正在发生的事情。

根据定义：

1. 赋值运算符计算右侧表达式，并将其存储在临时变量中。

   1.1。x的当前值被复制到此临时变量中

   1.2。x现在增加。

2. 然后将临时变量复制到表达式的左侧，这就是偶然的x！因此，这就是x的旧值再次复制到自身中的原因。

这很简单。

这是因为在这种情况下它永远不会增加。x++将先使用它的值，然后再递增，例如：

x = 0;

但是，如果这样做，++x;将会增加。

该值保持为0，因为的值为x++0。在这种情况下，x是否增加值并不重要，将x=0执行分配。这将覆盖临时增加的值x（“非常短的时间”为1）。

这可以像您期望的那样工作。这是前缀和后缀之间的区别。

int x = 0; 
while (x < 3)    x = (++x);

将x ++视为函数调用，它“返回” 增量之前的X （这就是为什么它称为后增量）的原因。

因此操作顺序为：
1：在递增之前缓存x的值
2：递增x
3：返回缓存的值（递增之前的x）
4：返回值分配给x

当++位于rhs上时，在数字递增之前返回结果。更改为++ x，就可以了。Java将对此进行优化以执行单个操作（将x分配给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

因此，仅交换前两行，即可更改语义，以使增量后的值（即表达式的“值”）保留在堆栈顶部，即增量后的值。

    x++
=: (x = x + 1) - 1

所以：

   x = x++;
=> x = ((x = x + 1) - 1)
=> x = ((x + 1) - 1)
=> x = x; // Doesn't modify x!

鉴于

   ++x
=: x = x + 1

所以：

   x = ++x;
=> x = (x = x + 1)
=> x = x + 1; // Increments x

当然，最终结果与正好x++;或++x;在线本身相同。

 x = x++; (increment is overriden by = )

由于上述陈述，x永远不会达到3；

我想知道Java规范中是否有任何东西可以精确定义其行为。（该声明的明显含义是我懒得检查。）

从汤姆的字节码中注意到，关键行是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

要么

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

应该无关紧要。我认为，任何一种实施方式都应该有效。

对于编写依赖于此行为的代码，我会非常谨慎。在我看来，它看起来非常依赖于实现，在规范之间。唯一会有所不同的是，您是否做了疯狂的事情（例如此处的示例），或者是否有两个线程正在运行并且取决于表达式中的求值顺序。

我认为是因为在Java ++中，优先级比=（赋值）高...是吗？看看http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.html ...

如果您写x = x + 1 ... +的优先级高于=（赋值）

该x++表达式的计算结果为x。该++部分会影响评估后的值，而不是声明后的值。所以x = x++有效地翻译成

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

在将值递增1之前，已将值分配给变量。

这是因为帖子增加了。这意味着在对表达式求值后，变量将递增。

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

x现在为10，但y为9，即x递增之前的值。

请参阅“职位增量定义”中的更多内容。

检查以下代码，

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

输出将是

temp = 0
x = 0

post increment表示递增该值并在递增之前返回该值。这就是为什么值temp是0。那么，如果temp = i和这在循环中（除了第一行代码），该怎么办？就像问题中一样!!!!

增量运算符将应用于您分配给的相同变量。那是麻烦。我确信您可以在运行该程序时看到x变量的值。这应该清楚说明循环永远不会结束的原因。