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


Java: Prefix/postfix of increment/decrement operators?

从下面或这里的程序中，为什么最后一次调用System.out.println(i)会打印值7？

1
2
3
4
5
6
7
8
9
10
11
12
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"
     }
}
相关讨论

1
2
i = 5;
System.out.println(++i); //6

这将打印出"6"，因为它需要我向它添加一个并返回值。5+1=6；这是预混，在操作中使用之前添加到数字。

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

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

然后，当您打印出i时，它会显示i的实际值，因为它是递增的。七

相关讨论

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

另一种解释方法是：

++i给出new i的结果，i++给出原i的结果，存储new i供下一步行动使用。

一种思考的方法是，在表达式中做一些其他的事情。当您打印i的当前值时，它将取决于i在表达式内或表达式后是否发生了更改。

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

在计算结果之前，对i进行评估(更改)。打印此表达式的i，显示用于此表达式的i的更改值。

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

计算结果后，对i进行评价。因此，从这个表达式打印i给出了这个表达式中使用的i的原始值，但是i仍然被更改以供进一步使用。因此，在表达式后立即打印EDOCX1的值(4)，将显示EDOCX1的新增量值(4)。由于i的值发生了变化，无论是打印还是使用。

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

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

1
2
3
4
5
6
7
8
9
  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"

把++i和i++想象成与i = i+1.相似，但两者并不相同。区别在于i得到新的增量。

在++i中，增量立即发生。

但是，如果i++存在，那么当程序进入下一行时，就会发生增量。

看看这里的代码。

1
2
3
4
5
6
7
8
9
int i = 0;
while(i < 10){
   System.out.println(i);
   i = increment(i);
}

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

这将导致不结束的循环。因为i将以原始值返回，在分号之后，我将递增，但返回值没有。因此，i永远不会实际返回递增值。

为什么不更新变量？

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

你对我什么都不做的台词没有区别。

请注意，对于分配，这也是正确的：

1
2
3
i = 0;
test = ++i;  // 1
test2 = i++; // 1
1
System.out.println(i++);  //"6"

这会将我在这行代码(6)之前的值发送给println，然后递增i(到7)。

它为最后一条语句打印7，在上面的语句中是cos，它的值是6，当最后一条语句被打印时，它增加到7。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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.
    }
}

也许您可以用这个例子更好地理解前缀/后缀。

1
2
3
4
5
6
7
8
9
10
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);
    }
}

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

1
2
3
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

现在，

1
2
i=3;
System.out.println(i++);

等于

1
2
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"