Java: Prefix/postfix of increment/decrement operators?

Question

From the program below or here, why does the last call to System.out.println(i) print the value 7?

class PrePostDemo {
     public          


        

Answer 1

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

This prints out "6" because it takes i adds one to it and returns the value. 5+1=6; This is prefixing, adding to the number before using it in the operation.

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

This prints out "6" because it takes i, stores a copy, adds 1 and returns the copy. So you get the value that i was, but also increment it at the same time. Therefore you print out the old value but it gets incremented. The beautfy of a postfix increment.

Then when you print out i, it shows the real value of i because it had been incremented. 7

Answer 2

Maybe you can understand better Prefix/postfix with this example.

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

Answer 3

I know this is a super old question, but I didn't see this type of answer listed. Looking at an example of how the actual operators is implemented is helpful for me, maybe it would be helpful for someone else

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

Answer 4

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

This sends println the value I had prior to this line of code (6), and then increments I (to 7).

Answer 5

I know this has been answered, but thought another explanation may be helpful.

Another way to illustrate it is:

++i will give the result of the new i, i++ will give the result of the original i and store the new i for the next action.

A way to think of it is, doing something else within the expression. When you are printing the current value of i, it will depend upon whether i has been changed within the expression or after the expression.

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

i is evaluated (changed) before the result is calculated. Printing i for this expression, shows the changed value of i used for this expression.

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

i is evaluated after the result in calculated. So printing i from this expression gives the original value of i used in this expression, but i is still changed for any further uses. So printing the value for i immediately after the expression, will show the new incremented value of i. As the value of i has changed, whether it is printed or used.

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

---

If you kept a consistent pattern and included print lines for all the values:

  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"

Answer 6

Think of ++i and i++ as SIMILAR to i = i+1. But it is NOT THE SAME. Difference is when i gets the new increment.

in ++i , increment happens immediately.

but if i++ is there increment will happen when program goes to next line.

Look at code here.

int i = 0;
while(i < 10){
   System.out.println(i);
   i = increment(i);
}

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

This will result non ending loop. because i will be returned with original value and after the semicolon i will get incremented but returned value has not been. Therefore i will never actually returned as an incremented value.