Java: префикс/постфикс операторов increment/decment?

Ответ 1

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

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

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

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

Затем, когда вы печатаете i, он показывает реальное значение i, потому что он был увеличен. 7

Ответ 2

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

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

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

Ответ 3

Думайте о ++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 будет возвращено с исходным значением, и после точки с запятой я получу инкремент, но возвращенное значение не было. Поэтому i никогда не будет возвращено как увеличенное значение.

Ответ 4

System.out.println(i++);  // "6"

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

Ответ 5

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

• Postfix: передает текущее значение я в функцию и затем увеличивает его.
• Префикс: увеличивает текущее значение и затем передает его функции.

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

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

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

Ответ 6

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

Ответ 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

Теперь,

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"

Ответ 8

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

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

Ответ 9

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

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

Ответ 10

Я знаю, что это очень старый вопрос, но я не видел этот тип ответа в списке. Мне полезно посмотреть на пример того, как реализованы фактические операторы, может быть, это будет полезно для кого-то другого

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