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"
     }
}
25
java post-increment pre-increment

9 ответов

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

это выводит "6", потому что требуется I добавляет к нему один и возвращает значение. 5+1=6; это префикс, добавление к числу перед его использованием в операции.

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

это печатает "6", потому что он принимает i, сохраняет копию, добавляет 1 и возвращает копию. Таким образом, вы получаете значение, которым я был, но также увеличиваете его одновременно. Поэтому вы распечатываете старое значение, но оно увеличивается. В beautfy из постфиксного инкремента.

затем при печати из i он показывает реальную ценность i, потому что она была увеличена. 7

57

я знаю, что на это был дан ответ, но подумал, что другое объяснение может быть полезно.

другой способ проиллюстрировать это:

++i даст результат new i, i++ даст результат оригинала i и магазине new i для следующего действия.

способ думать об этом-это делать что-то еще в пределах выражения. При печати текущего значения i, это будет зависеть от того, какие i была изменилось в выражении или после выражения.

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

i оценивается (изменяется) перед вычислением результата. Печать i для этого выражения отображается измененное значение i использовать для этого выражения.

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"
12

думать ++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++;
}

это приведет к не конечному циклу. потому что я буду возвращен с исходным значением и после точка с запятой i будет увеличена, но возвращенное значение не было. Поэтому я никогда не вернусь как увеличенное значение.

3

почему переменная не была обновлена?

  • Postfix: передает текущее значение i функции,а затем увеличивает его.
  • Prefix: увеличивает текущее значение, а затем передает его функции.

строки, в которых вы ничего не делаете со мной, не имеют значения.

обратите внимание, что это также верно для выполнения заданий:

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

об этом передает println значение, которое я имел до этой строки кода (6), а затем увеличивает I (до 7).

2

печати 7 для последнего оператора, cos в заявлении выше, это значение 6 и он увеличивается до 7, когда последний оператор печатается

1

хорошо подумать об этом с точки зрения временных переменных.

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

Теперь

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

эквивалентно

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"
0

возможно, вы можете лучше понять префикс / постфикс с этим примером. 

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);
    }
}
0

вот мой ответ. Некоторым из вас это легко понять. 

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. 
    }
}
0