Думайте о ++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 никогда не будет возвращено как увеличенное значение.

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

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

++i даст результат new i, i++ даст результат оригинала i и сохранит new 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"

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

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

Он печатает 7 для последнего утверждения, потому что в приведенном выше утверждении его значение равно 6 и увеличивается до 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"

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

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

Линии, где ты ничего не делаешь, не имеют значения.

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

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

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

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

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

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