what pre and post increment in java is used for except for (shorthand,getting value before increment or after increment)?

Question

I know that pre and post increment(like ++i, i++, --i, i--) used for shorthand, getting value before increment or after increment. this can be achieved with other methods too . but, Do they have another additional advantage?

Answer 1

So, what are the differences between:

• x++
• ++x
• x += 1
• x = x + 1

As mentioned by Louis Wasserman in a comment:

There shouldn't be any other advantage after the JIT has the chance to work over the code. They'll get compiled down to the same thing.

This is however only a true statement if the 4 are used as standalone statements. All 4 of them can also be used as an expression, in which case they are not all the same:

• a = x++ is the value before incrementing x.
• a = ++x, a = x += 1, and a = x = x + 1 are all the value after incrementing x.

Also, x = x + 1 evaluates x twice, while the other 3 only evaluates it once. For a simple x that makes no difference, but for e.g. an array lookup a[k] that makes a difference, especially if "k" can change.

Example:

// setup
int[] a = { 5, 15, 25 };
int k = 0;

// result of each if run right after setup
a[k++]++;            // k = 1, a = [6, 15, 25]
++a[k++];            // k = 1, a = [6, 15, 25]
a[k++] += 1;         // k = 1, a = [6, 15, 25]

a[++k]++;            // k = 1, a = [5, 16, 25]
a[k+=1]++;           // k = 1, a = [5, 16, 25]
a[k=k+1]++;          // k = 1, a = [5, 16, 25]

a[k++] = a[k++] + 1; // k = 2, a = [16, 15, 25]

Now, that last one is a doozie. For a long explanation of how that works, see this answer, but it evaluates left-to-right:

k = 0;    a[k++] = a[k++] + 1;
k = 1;    a[0] = a[k++] + 1;
k = 2;    a[0] = a[1] + 1;
k = 2;    a[0] = 15 + 1;
k = 2;    a[0] = 16;

To recap:

• There is no difference if run as a statement, and x has no side-effects (very common).
• As an expression, the x++ post-increment evaluates to a different value.
• x = x + 1 evaluates x twice, which matters if x has side-effects (rare).

Other than that, it is a matter of choice which to use.

---

Bytecode

For those curious about bytecode, using Eclipse compiler, if "x" is a simple variable, all 4 as statements compiles to

iinc          1, 1

As expressions with simple variables, e.g. y = x++, they compile differently:

// y = x++;
iload_2
iinc          2, 1
istore_1

// y = ++x;   y = x += 1;   y = x = x + 1;
iinc          2, 1
iload_2
istore_1

With array:

// y = a[k]++;
aload_1
iload_2
dup2
iaload
dup_x2
iconst_1
iadd
iastore
istore_3

// y = ++a[k];   y = a[k] += 1;
aload_1
iload_2
dup2
iaload
iconst_1
iadd
dup_x2
iastore
istore_3

// y = a[k] = a[k] + 1;
aload_1
iload_2
aload_1
iload_2
iaload
iconst_1
iadd
dup_x2
iastore
istore_3