How do the post increment (i++) and pre increment (++i) operators work in Java?

• ++a increments and then uses the variable.
• a++ uses and then increments the variable.

If you have

a = 1; 

and you do

System.out.println(a++); //You will see 1 //Now a is 2 System.out.println(++a); //You will see 3 

codaddict explains your particular snippet.

In both cases it first calculates value, but in post-increment it holds old value and after calculating returns it

++a

1. a = a + 1;
2. return a;

a++

1. temp = a;
2. a = a + 1;
3. return temp;

i = ++a + ++a + a++; 

is

i = 6 + 7 + 7 

Working: increment a to 6 (current value 6) + increment a to 7 (current value 7). Sum is 13 now add it to current value of a (=7) and then increment a to 8. Sum is 20 and value of a after the assignment completes is 8.

i = a++ + ++a + ++a; 

is

i = 5 + 7 + 8 

Working: At the start value of a is 5. Use it in the addition and then increment it to 6 (current value 6). Increment a from current value 6 to 7 to get other operand of +. Sum is 12 and current value of a is 7. Next increment a from 7 to 8 (current value = 8) and add it to previous sum 12 to get 20.

++a increments a before it is evaluated. a++ evaluates a and then increments it.

Related to your expression given:

i = ((++a) + (++a) + (a++)) == ((6) + (7) + (7)); // a is 8 at the end i = ((a++) + (++a) + (++a)) == ((5) + (7) + (8)); // a is 8 at the end 

The parenteses I used above are implicitly used by Java. If you look at the terms this way you can easily see, that they are both the same as they are commutative.

In the above example

int a = 5,i; i=++a + ++a + a++; //Ans: i = 6 + 7 + 7 = 20 then a = 8 i=a++ + ++a + ++a; //Ans: i = 8 + 10 + 11 = 29 then a = 11 a=++a + ++a + a++; //Ans: a = 12 + 13 + 13 = 38 System.out.println(a); //Ans: a = 38 System.out.println(i); //Ans: i = 29 

I believe however if you combine all of your statements and run it in Java 8.1 you will get a different answer, at least that's what my experience says.

The code will work like this:

int a=5,i; i=++a + ++a + a++; /*a = 5; i=++a + ++a + a++; => i=6 + 7 + 7; (a=8); i=20;*/ i=a++ + ++a + ++a; /*a = 5; i=a++ + ++a + ++a; => i=8 + 10 + 11; (a=11); i=29;*/ a=++a + ++a + a++; /*a=5; a=++a + ++a + a++; => a=12 + 13 + 13; a=38;*/ System.out.println(a); //output: 38 System.out.println(i); //output: 29 

++a is prefix increment operator:

• the result is calculated and stored first,
• then the variable is used.

a++ is postfix increment operator:

• the variable is used first,
• then the result is calculated and stored.

Once you remember the rules, EZ for ya to calculate everything!

Presuming that you meant

int a=5; int i; i=++a + ++a + a++; System.out.println(i); a=5; i=a++ + ++a + ++a; System.out.println(i); a=5; a=++a + ++a + a++; System.out.println(a); 

This evaluates to:

i = (6, a is now 6) + (7, a is now 7) + (7, a is now 8) 

so i is 6 + 7 + 7 = 20 and so 20 is printed.

i = (5, a is now 6) + (7, a is now 7) + (8, a is now 8) 

so i is 5 + 7 + 8 = 20 and so 20 is printed again.

a = (6, a is now 6) + (7, a is now 7) + (7, a is now 8) 

and after all of the right hand side is evaluated (including setting a to 8) THEN a is set to 6 + 7 + 7 = 20 and so 20 is printed a final time.

when a is 5, then a++ gives a 5 to the expression and increments a afterwards, while ++a increments a before passing the number to the expression (which gives a 6 to the expression in this case).

So you calculate

i = 6 + 7 + 7 i = 5 + 7 + 8 

Pre-increment means that the variable is incremented BEFORE it's evaluated in the expression. Post-increment means that the variable is incremented AFTER it has been evaluated for use in the expression.

Therefore, look carefully and you'll see that all three assignments are arithmetically equivalent.

pre-increment and post increment are equivalent if not in an expression

int j =0; int r=0 for(int v = 0; v<10; ++v) { ++r; j++; System.out.println(j+" "+r); } 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 

I believe you are executing all these statements differently
executing together will result => 38 ,29

int a=5,i; i=++a + ++a + a++; //this means i= 6+7+7=20 and when this result is stored in i, //then last *a* will be incremented <br> i=a++ + ++a + ++a; //this means i= 5+7+8=20 (this could be complicated, //but its working like this),<br> a=++a + ++a + a++; //as a is 6+7+7=20 (this is incremented like this) 

a=5; i=++a + ++a + a++; 

is

i = 7 + 6 + 7 

Working: pre/post increment has "right to left" Associativity , and pre has precedence over post , so first of all pre increment will be solve as (++a + ++a) => 7 + 6 . then a=7 is provided to post increment => 7 + 6 + 7 =20 and a =8.

a=5; i=a++ + ++a + ++a; 

is

i=7 + 7 + 6 

Working: pre/post increment has "right to left" Associativity , and pre has precedence over post , so first of all pre increment will be solve as (++a + ++a) => 7 + 6.then a=7 is provided to post increment => 7 + 7 + 6 =20 and a =8.

The way I look at these expressions are in terms of using/passed on. What value on the right am I using and what value is being passed on to the next term.

given int i = 5

• ++i - increments to 6, uses 6 and passes on 6
• --i - decrements to 4 uses 4 and passes on 4
• i++ - uses 5 increments to 6 and passes on 6
• i-- - uses 5 decrements to 4 and passes on 4

Examples (uses/passes on)

prefix operations

int i = 5; int k = 5; // 5 + (4,4) (3,3) (4,4) (5,5) (4,4) (5,4) (4,4) i += --i + --i + ++i + ++i + --i + ++i + --i; k += 4 + 3 + 4 + 5 + 4 + 5 + 4; System.out.println("i = " + i); //i = 34 System.out.println("k = " + k); //k = 34; 

postfix operations

i = 5; k = 5; // 5 + (5,6) (6,5) (5,4) (4,5) (5,6) (6,5) (5,6) i += i++ + i-- + i-- + i++ + i++ + i-- + i++; k += 5 + 6 + 5 + 4 + 5 + 6 + 5; System.out.println("i = " + i); //i = 41 System.out.println("k = " + k); //k = 41; 

both operations

i = 5; k = 5; // 5 + (4,5) (4,4) (3,3) (3,4) (4,5) (4,4) (4,5) i += i++ + --i + --i + i++ + i++ + --i + i++ k += 4 + 4 + 3 + 3 + 4 + 4 + 4; System.out.println("i = " + i); //i = 34 System.out.println("k = " + k); //k = 34;