Java：递增/递减运算符的前缀/后缀？

从下面的程序或，为什么最后一次调用

System.out.println（i）

打印值

7

class PrePostDemo {
     public static void main(String[] args){
          int i = 3;
          i++;
          System.out.println(i);    // "4"
          ++i;             
          System.out.println(i);    // "5"
          System.out.println(++i);  // "6"
          System.out.println(i++);  // "6"
          System.out.println(i);    // "7"
     }
}

---

这将发送

println

在这行代码（6）之前的值，然后增加I（到7）。

为什么变量没有被更新

• 后缀：将i的当前值传递给函数，然后将其递增
• 前缀：增加当前值，然后将其传递给函数

你不跟我做任何事的台词没什么区别

请注意，对于工作分配也是如此：

i = 0;
test = ++i;  // 1
test2 = i++; // 1

这会打印出“6”，因为它取i，加1，然后返回值：5+1=6。这是一种前缀，在操作中使用之前添加到数字

i = 6;
System.out.println(i++); //6 (i = 7, prints 6)

这会打印出“6”，因为它接受i，存储一个副本，向变量添加1，然后返回副本。所以你得到了我的值，但同时也增加了它。因此，您打印出旧值，但它会递增。后缀增量的美

---

然后当你打印出i时，它显示i的真实值，因为它已经增加了：7。

我们可以用临时变量来考虑它

i =3 ;
i ++ ; // is equivalent to:   temp = i++; and so , temp = 3 and then "i" will increment and become     i = 4;
System.out.println(i); // will print 4

现在,

相当于

temp = i++;  // temp will assume value of current "i", after which "i" will increment and become i= 4
System.out.println(temp); //we're printing temp and not "i"

---

把

++i

和

i++

想象成类似于

i=i+1.

但它不一样。区别在于

i

获取新增量时

在

++i

中，增量立即发生

但若

i++

存在，当程序转到下一行时，将发生增量

看看这里的代码

int i = 0;
while(i < 10){
   System.out.println(i);
   i = increment(i);
}

private int increment(i){
   return i++;
}

inti=0；
而（i<10）{
系统输出打印LN（i）；
i=增量（i）；
}
私有整数增量（i）{
返回i++；
}

---

这将导致无结束循环。因为

i

将返回原始值，在分号之后，i将递增，但返回值尚未更改。因此，

i

实际上永远不会作为递增值返回。

我知道这已经得到了回答，但我认为另一种解释可能会有所帮助

另一种解释方法是：

++i

将给出

新i

的结果，

i++

将给出原始

i

的结果，并存储

新i

，以便下一步操作

思考它的一种方式是，在表达式中做一些其他的事情。打印

i

的当前值时，它将取决于

i

是在表达式内还是在表达式后更改

    int i = 1;
result i = ++i * 2 // result = 4, i = 2

result i = i++ * 2 // result = 2, i = 2

i

在计算结果之前进行评估（更改）。为此表达式打印

i

，将显示用于此表达式的

i

的更改值

    int i = 1;
result i = ++i * 2 // result = 4, i = 2

result i = i++ * 2 // result = 2, i = 2

i

在计算结果后进行评估。因此，从此表达式中打印

i

将给出此表达式中使用的

i

的原始值，但仍会更改

i

，以备将来使用。因此，在表达式之后立即打印

i

的值，将显示

i

的新增量值。无论是打印还是使用，

i

的值已更改

result i = i++ * 2 // result = 2, i = 2
System.out.println(i); // 2

---

如果您保持了一致的图案，并且包含了所有值的打印行：

  int i = 3; 
System.out.println(i);    //  3
System.out.println(i++);  //  3
System.out.println(i);    // "4"
System.out.println(++i);  //  5          
System.out.println(i);    // "5"
System.out.println(++i);  // "6"
System.out.println(i++);  // "6"
System.out.println(i);    // "7"

---

也许你可以通过这个例子更好地理解前缀/后缀

public class TestPrefixPostFix 
{
    public static void main (String[] args)
    { 
        int x=10;
        System.out.println( (x++ % 2 == 0)?"yes "+ x: " no "+x);
        x=10;
        System.out.println( (++x % 2 == 0)?"yes "+ x: " no "+x);
    }
}    

---

这是我的答案。你们中的一些人可能会发现这很容易理解

package package02;

public class C11PostfixAndPrefix {

    public static void main(String[] args) {
        // In this program, we will use the value of x for understanding prefix 
        // and the value of y for understaning postfix. 
        // Let's see how it works. 

        int x = 5; 
        int y = 5; 

        Line 13:   System.out.println(++x);  // 6   This is prefixing. 1 is added before x is used. 
        Line 14:   System.out.println(y++);  // 5   This is postfixing. y is used first and 1 is added. 

        System.out.println("---------- just for differentiating");

        System.out.println(x);  // 6   In prefixing, the value is same as before {See line 13}
        System.out.println(y);  // 6   In postfixing, the value increases by 1  {See line 14} 

        // Conclusion: In prefixing (++x), the value of x gets increased first and the used 
        // in an operation. While, in postfixing (y++), the value is used first and changed by
        // adding the number. 
    }
}

---

对于最后一个语句，它打印出7，因为在上面的语句中，它的值是6，当最后一个语句打印出来时，它会增加到7

我知道这是一个非常老的问题，但我没有看到列出这种类型的答案。看一个如何实现实际运算符的示例对我很有帮助，也许对其他人也有帮助

class Integer {
  private int __i;

  function Integer ++() { // prefix operator i.e. ++x
    __i+=1; //increment
    return this; //return object with incremented value
  }

  function Integer ++(Integer x) { //postfix operator i.e. x++
    __i+=1; //increment
    return x; //return original object
  }
}

---

这可能会有帮助。。我也花了很长时间才明白这个谜团

公共班机{ 公共静态void main（字符串[]args）{

}

---

}

我相信我多少能理解你的误解是从哪里来的。您认为只有当一个新值本身是一个语句时，它才会被分配给

i

？向函数传递参数时，语句（在本例中为post和prefix）在传递之前执行。将后缀和前缀之间的行为差异添加到下面的答案中，您就明白了为什么会得到该输出。此处所有其他答案的可能重复项表示“i”的值将首先使用，然后它将递增，但正如您所说的，值将递增，然后返回旧值的副本是正确的。以i=5为例，我们了解得更多；i=i++；如果首先赋值并递增，那么我将是6，但在这种情况下是5，询问者有一个代码，请用代码解释你的答案

class Integer {
  private int __i;

  function Integer ++() { // prefix operator i.e. ++x
    __i+=1; //increment
    return this; //return object with incremented value
  }

  function Integer ++(Integer x) { //postfix operator i.e. x++
    __i+=1; //increment
    return x; //return original object
  }
}

int x = 5;
int y=5;

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

System.out.println("------");

System.out.println(x);
System.out.println(y);