Home / Questions / 376
Accepted
Jordi Castilla
Asked: 2020-12-04 09:04:54 +0800 CST 2020-12-04 09:04:54 +0800 CST

x++ 和 ++x 的区别

  • 772

在代码中我多次看到x++循环，但有时我发现++x.

这两种表达方式有区别吗？

java

7 Answers

  1. 发布增量：

    x++, 表达式的值是存储新值之前变量的值。

    例子：

    int x = 1;
System.out.println(x++); // imprime 1.
System.out.println(x);   // imprime 2.

    预增加：

    ++x, 表达式的值是新值存储后变量的值。

    例子：

    int x = 1;
System.out.println(++x); // imprime 2. 
System.out.println(x);   // imprime 2.

    x--和_--x

    例子：

    int x = 1;
System.out.println(x--); // imprime 1. 
System.out.println(x);   // imprime 0.

int x = 1;
System.out.println(--x); // imprime 0. 
System.out.println(x);   // imprime 0.

    更多信息：

    • 41
  2. Best Answer

    在代码中我多次看到x++循环，但有时我发现自己++x。

    如果您指的是这种类型的结构：

    public static void main(String[] args) {
    for (int i = 0; i < 10; ++i) {
        System.out.println(i);
    }
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
    }
}

    ……那就没有区别了。如果我们看到字节码：

    public static void main(java.lang.String[]);
  Code:
     0: iconst_0
     1: istore_1
     2: iload_1
     3: bipush        10
     5: if_icmpge     21
     8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
    11: iload_1
    12: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
    15: iinc          1, 1
    18: goto          2
    21: iconst_0
    22: istore_1
    23: iload_1
    24: bipush        10
    26: if_icmpge     42
    29: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
    32: iload_1
    33: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
    36: iinc          1, 1
    39: goto          23
    42: return

    在这两种情况下，就在调用println( invokevirtual #3) 之后，变量 1（在代码中适用于两种情况）都加1。i参见.iinc 1, 1goto

    但是，如果你的意思是这样的：

    public static void main(String[] args) {
    for (int i = 0; i < 10;) {
        System.out.println(i++);
    }
    for (int i = 0; i < 10;) {
        System.out.println(++i);
    }
}

    ……那就有区别了。检查字节码：

    public static void main(java.lang.String[]);
  Code:
     0: iconst_0
     1: istore_1
     2: iload_1
     3: bipush        10
     5: if_icmpge     21
     8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
    11: iload_1
    12: iinc          1, 1
    15: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
    18: goto          2
    21: iconst_0
    22: istore_1
    23: iload_1
    24: bipush        10
    26: if_icmpge     42
    29: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
    32: iinc          1, 1
    35: iload_1
    36: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
    39: goto          23
    42: return

    在第一种情况下，首先i加载变量 1 ( ) 的值以在println. 见iload_1。然后这个变量加 1。见iinc 1, 1。

    在第二种情况下，变量 1 ( i) 的值首先增加 1，参见iinc 1, 1。i然后加载变量 1() 的值以在println. 见iload_1。

    • 40

  3. 区别不在于增量是在计算表达式之前还是之后执行，而在于两个表达式的返回值。

    根据部分中的官方 Java 规范：15.14.2。后缀增量运算符 ++和15.15.1。前缀增量运算符 ++

    15.14.2。后缀增量运算符 ++

    ...后缀增量表达式的值是存储新值之前的变量值。

    翻译

    15.14.2。后缀增量运算符 ++

    后缀增量表达式的值是存储新值之前变量的值。

    一样

    15.15.1。前缀增量运算符 ++

    前缀增量表达式的值是新值存储后变量的值。

    翻译

    15.15.1。前缀增量运算符 ++

    前缀增量表达式的值是新值存储后变量的值。

    两者都将变量x加 1。不同之处在于表达式++x返回增加后的变量的值，而表达式x++返回变量增加前的原始值。

    即：

    int x = 5;
System.out.println(++x);  // Imprime 6, x vale 6: El resultado de la expresión ++x es 6 y se imprime 6
System.out.println(x); // Imprime 6, x vale 6: x ya se incrementó por lo que devuelve 6

    尽管：

    int x = 5;
System.out.println(x++);  // Imprime 5, x vale 6. La variable x ya es 6 pero el resultado de la expresión es 5 por lo que se imprime 5
System.out.println(x); // Imprime 6, x vale 6: x ya se incrementó por lo que devuelve 6
    • 18

  4. 我知道这个问题是用Java标记的，我不知道这种语言的实现（虽然我想它会类似），但是在C#中，虽然说“一个返回之前的值”是正常和直观的递增，其他之后”，这或多或少给出了基本含义……现实情况是，实现不是那样的，它有一个非常具体的事件序列。

    如果我们单独使用它，这不是问题：x++;它不会带来任何问题，简单的解释是有效的......但是如果我们进入多线程，以及具有不同运算符优先级的长操作，事情就会改变。

    正如我所说，我不知道 Java 是如何做到的，但是在 C# 中，每个命令的顺序都是完美定义的（我想在 Java 中它会是类似的）：

    对于前缀类型 ( ++x)，顺序为：

    1. 它被评估x以产生变量
    2. 变量的值被复制到临时空间
    3. 临时变量递增并产生一个新值（不会覆盖临时变量）
    4. 新值存储在变量中
    5. 返回新值（不是变量）

    对于后缀类型 ( x++)，顺序为：

    1. 它被评估x以产生变量
    2. 变量的值被复制到临时空间
    3. 临时变量递增并产生一个新值（不会覆盖临时变量）
    4. 新值存储在变量中
    5. 返回临时副本的值

    因此，这两种情况的事件顺序都以相同的顺序发生，变量的求值和增量都没有改变，唯一改变的是返回的值。只有第 5 步有区别。

    在使用方法扩展的 C# 中，这很容易测试......在 Java 中我不太清楚（我只有 Java 的基本概念）。

    很抱歉使用 C# 回答问题，问题标记为 Java，但正如我所说，我怀疑实现应该是相似的，如果不一样的话。

    • 4

  5. 两者都将变量的值增加1. 如果你在一行中使用它们，它是唯一的表达式，没有区别，但如果你和其他人一起执行它们，就会有一个重要的变化。

    • ++x 在计算表达式之前执行此操作。它也被称为PREINCREMENTO

      例子：

      int x = 5;
System.out.println(++x); // escribira 6 porque ejecutará x + 1 ANTES de printar
System.out.println(x);   // volverá a escribir 6!!!!

    • x++ 在计算表达式后执行此操作。它也被称为POSTINCREMENTO

      例子：

      int x = 5;
System.out.println(x++); // escribirá 5 porque ejecutará x + 1 DESPUÉS de printar
System.out.println(x);   // escribirá 6

    当您执行没有计数器的循环（例如 for-each）或通过填充同一对象的各种属性时从数组进行赋值时，这种类型的表达式也很常见，从而节省了一行代码并获得了可读性。

    arrayALlenar[i++] = elemento;

    代替

    arrayALlenar[i] = elemento;  
i++;
    • 3

  6. ++x在调用之前递增变量。 X++调用它然后递增它。

    • 3

  7. 它们都做同样的事情，只是后增量在存储增量值之前计算为变量的值，而前增量在存储增量值之后计算为变量的值。

    前后增量在Java 语言规范 (JLS)的两个部分中定义，我在其中复制了对这个问题很重要的部分（强调我的）：

    • 15.14.2：后缀增量运算符++
      （..省略..）
      在运行时，如果表达式的求值突然完成，则后缀增量表达式出于同样的原因突然完成并且没有增量。否则，将值 1 添加到变量的值，并将总和存储在变量中。(...省略...) 后缀增量表达式的值是新值存储之前的变量值。
      （..省略..）

    • 15.15.1。前缀增量运算符 ++
      (..省略..)
      在运行时，如果表达式的求值突然完成，那么前缀减量表达式出于相同的原因突然完成并且没有增量。否则，将值 1 添加到变量的值，并将总和存储在变量中。(...省略...) 后缀增量表达式的值是新值存储后变量的值。
      （..省略..）

    请注意，除了计算表达式的值之外，一切都是相同的，该值是变量在存储后缀增量的新值之前所具有的值，也是变量在其增加之后具有的值前缀增量。

    所有这些在如下代码中都没有重要性： 

    for ( int n=1; n<10; ++n)
for ( int n=1; n<10; n++)

    在该代码中，对于 的相同值n，表达式++n和n++被评估为不同的值，但这无关紧要，因为没有使用该值，唯一具有显着影响的是变量增加 1 的事实，这这两种情况都会发生。两个循环将执行相同数量的迭代。

    但它在如下代码中很重要：

    int a; int b;
a = 3;
b = a++;
System.out.println( "a="+a + " b=" + b);
a = 3;
b = ++a; 
System.out.println( "a="+a + " b=" + b);

    输出在哪里：

    a=4 b=3
    a=4 b=4

    在表达式b = a++中，对变量a（等于 3）进行求值，将 1 加到该值上，并将和 (4) 的结果存储在变量 a 中。表达式的结果a++是变量a 在存储新值（为 3）之前的值，因此表达式的结果a++是 3。而这个 3 就是存储在b.

    在表达式b = ++a中，对变量a（等于 3）进行求值，将 1 加到该值上，并将总和 (4) 的结果存储在变量 中a。表达式的结果++a是变量存储新值（即 4）a 后++a的值，所以表达式的结果是 4。而这个，4，就是存储在b.

    通过严格遵循这种评估前缀和后缀增量的方式，我们可以正确地评估它们所涉及的任何表达式。例如 ：

        int a; int b;
    a = 3;
    b = ++a + a++;
    System.out.println( "a="+a + " b=" + b);
    a = 3;
    b = a++ + a++; 
    System.out.println( "a="+a + " b=" + b);

    在第一个表达式b中，它最终为 8，因为第++a一个表达式的计算结果为 4（存储增量后的值），当第二个表达式执行时，a++变量a已经包含 4，它增加到 5，但表达式a++是变量在递增之前的表达式，因此计算结果为 4。并且 4+4=8。
    在第二个表达式b中，它最终为 7，因为第a++一个表达式的计算结果为 3（存储增量之前的值），当第二个表达式执行时，a++变量a已经包含 4，它增加到 5，但是表达式a++是变量在递增之前的表达式，因此它的计算结果为 4。并且 3+4=7。

    但最好不要那样做

    尽管我们完全了解前置和后置自增运算符的工作原理，但在非平凡的表达式中使用它们只会造成混淆。对你，对你的合作者，对你的协调员，对审查代码的人，对五年后必须处理代码的人，而编写代码的人早已离开公司，对猫...... .

    • 2