Java “x”后面是什么；x=x++&引用；？

执行时（窗帘后面）会发生什么

int x = 7;
x = x++;

---

也就是说，当一个变量在一条语句中后递增并赋值给它自己时？我编译并执行了这个<代码>x即使在整个语句之后仍然是7。在我的书中，它说

x

是递增的

它在“

x=x++；”

之后递增。如果您执行“

x=++x；

”

x

确实会递增，则为8。但是您正在将

x

的旧值重新赋给它本身

---

x++

递增

x

并返回其旧值

x=

将旧值重新分配给自身

因此，最后，

x

被分配回其初始值

x = x++;

相当于

int tmp = x;
x++;
x = tmp;

---

递增发生在调用x之后，因此x仍然等于7++当调用x时，x将等于8。当您为

x

重新赋值时，x仍然是7。尝试

x=++x

，您将得到8个其他选项

x++; // don't re-assign, just increment
System.out.println(x); // prints 8

---

当

intx=7时会发生什么；x=x++

ans->
x++
表示首先将x的值用于表达式，然后将其增加1。

这就是你的情况。RHS上的x值复制到LHS上的变量x，然后将
x
的值增加1

类似地，
++x
表示先将x的值增加1，然后在表达式中使用。

因此，在您的情况下，如果您执行
x=++x；/其中x=7


您将获得值8

为了更清楚，请尝试找出有多少printf语句将执行以下代码

while(i++ <5)   
  printf("%d" , ++i);   // This might clear your concept upto  great extend

while（i++
对于Java，请参见。这取决于编译器会发生什么。
这意味着：
x++
不等于
x=x+1

因为：

int x = 7; x = x++;
x is 7

int x = 7; x = x = x+1;
x is 8

现在看起来有点奇怪：

int x = 7; x = x+=1;
x is 8

非常依赖于编译器！
因为x++在将值赋给变量后会增加值。
依此类推，在执行该行的过程中：

x++;

变量x仍将具有原始值（7），但在另一行上再次使用x，例如

System.out.println(x + "");

我给你8英镑

如果要在赋值语句中使用递增的x值，请使用

++x;

这将使x增加1，然后将该值赋给变量x

[编辑]
它不是x=x++，而是x++；前者将x的原始值分配给它自己，因此它实际上在这一行上什么也不做。
++x
是增量前的
->
x在使用之前是增量的

x++
是增量后的
->
x是在使用后的增量

int x = 7; -> x get 7 value <br>
x = x++; -> x get x value AND only then x is incremented

intx=7；->x得到7值

x=x++；->x得到x值，然后x才递增
声明：

x = x++;

相当于：

tmp = x;   // ... this is capturing the value of "x++"
x = x + 1; // ... this is the effect of the increment operation in "x++" which
           //     happens after the value is captured.
x = tmp;   // ... this is the effect of assignment operation which is
           //     (unfortunately) clobbering the incremented value.

简言之，该声明没有任何效力

要点：


后缀递增/递减表达式的值是递增/递减发生之前的操作数的值。（对于前缀形式，该值是运算之后的操作数的值，）

赋值表达式的RHS在赋值给LHS之前会被完全评估（包括任何增量、减量和/或其他副作用）


<>注意，与C和C++不同，java中表达式的计算顺序是完全指定的，并且没有平台特定的变化空间。编译器只允许重新排序操作，如果这不会改变当前线程的角度执行代码的结果。我试图优化掉整个语句，因为可以证明它是不可行的


如果还不明显：


“x=x++；”几乎可以肯定是任何程序中的错误
OP（对于原始问题！）的意思可能是“x++；”，而不是“x=x++；”
在同一个变量上结合自动递增/递减和赋值的语句很难理解，因此无论其正确性如何，都应该避免使用。根本不需要编写这样的代码

希望像FindBugs和PMD这样的代码检查器会将这样的代码标记为可疑代码。
像
x=x++；
这样的结构表明您可能误解了
++
操作符的功能：

// original code
int x = 7;
x = x++;

在删除
++
运算符的基础上，让我们重写此代码以执行相同的操作：

// behaves the same as the original code
int x = 7;
int tmp = x; // value of tmp here is 7
x = x + 1; // x temporarily equals 8 (this is the evaluation of ++)
x = tmp; // oops! we overwrote y with 7

现在，让我们重写它以实现（我认为）您想要的：

// original code
int x = 7;
x++;

这里的微妙之处在于，<代码> ++> /COD>操作符修改了变量<代码> x>代码>，不同于一个表达式，如<代码> x+x>代码>，它将被评估为一个int值，但使变量<代码> x<代码>本身不变。考虑一个类似于< <代码> > < <代码>循环：
的构造。
for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

我还建议在大多数情况下不要在更大的表达式中使用
++
运算符。因为它在增量前后修改原始变量时的细微差别（
++x
和
x++
），很容易引入难以追踪的细微缺陷。
我认为这一争议可以在不深入代码和思考的情况下解决

将i++&++i视为函数，例如Func1和Func2

现在i=7；

Func1（i++）返回7，Func2（++i）返回8（每个人都知道这一点）。在内部，两个函数都将i增加到8，但它们返回的值不同

因此i=i++调用函数Func1。在函数中，i递增为8，但完成后函数返回7

因此，最终7被分配给i。（因此，最后i=7）
后增量运算符的工作如下：

存储操作数的上一个值
递增操作数的值
返回操作数的上一个值
所以声明

int x = 7;
x = x++; 

将被评估为
for(int i = 0; i < 10; i++)
{
    System.out.println(i);
}

for(int i = 0; i < 10; i = i + 1)
{
    System.out.println(i);
}

int x = 7;
x = x++; 

int x=7;
x=x++;

0  bipush 7     //Push 7 onto  stack
2  istore_1 [x] //Pop  7 and store in x
3  iload_1  [x] //Push 7 onto stack
4  iinc 1 1 [x] //Increment x by 1 (x=8)
7  istore_1 [x] //Pop 7 and store in x
8  return       //x now has 7

int x=7; 
x=++x;

0  bipush 7     //Push 7 onto stack
2  istore_1 [x] //Pop 7 and store in x
3  iinc 1 1 [x] //Increment x by 1 (x=8)
6  iload_1  [x] //Push x onto stack
7  istore_1 [x] //Pop 8 and store in x
8  return       //x now has 8

x = x++;

x = ++x;