Difference between a += 10 and a = a + 10 in java?

Question

may i know are(a += 10 and a = a + 10) these both the same or is there any difference or purpose is there. i got this doubt while studying about assignments in java.

Answer 1

There is no difference, one is shorthand for the other. Even the compiler will generate the same instructions for both.

Edit: the compiler does NOT generate the same code for both, as I just found out. Check this out:

dan$ cat Test.java
public class Test {
    public static void main(String[] args) {
        int a = 0;
        a = a + 10;
        a += 20;
    }
}

dan$ javap -c Test
Compiled from "Test.java"
public class Test extends java.lang.Object{
public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   bipush  10
   5:   iadd
   6:   istore_1
   7:   iinc    1, 20
   10:  return

}

So the short answer, especially for a Java beginner, or anyone who isn't worried about optimizing at the smallest level, is that they are interchangeable. The long answer will depend on me reading about iadd vs iinc.

Edit 2: Ok, I'm back. The instruction specs are (roughly) as follows:

iadd - adds the top two ints on the stack

iinc - increments a local variable by a constant

And as we saw above, we can save a couple of instructions using iinc, as long as there is a constant on the right hand side.

But what happens if we have

a += a?

Then the code looks like this:

   7:   iload_1
   8:   iload_1
   9:   iadd
   10:  istore_1

which is the same thing we get if we have a = a + a.

Answer 2

In the expressions you show, they are equivalent, in an expression like:

array[getIndex(context)][some / complex + expression] += offset;

you get an idea in which situations the += operator (and the other assignment operators) is useful. If the expression is non-trivial, the += operator prevents mistakes and improves readability and therefore maintainability.

Answer 3

As you've now mentioned casting... there is a difference in this case:

byte a = 5;
a += 10; // Valid
a = a + 10; // Invalid, as the expression "a + 10" is of type int

From the Java Language Specification section 15.26.2:

A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once.

Interestingly, the example they give in the spec:

short x = 3;
x += 4.6;

is valid in Java, but not in C#... basically in C# the compiler performs special-casing of += and -= to ensure that the expression is either of the target type or is a literal within the target type's range.

Answer 4

This is defined in the Java Language Specification, section 15.25.2. The salient part is:

A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once.

That is, in your case the difference is the implicit type cast:

byte a = 100;
a += 1000;    // compiles
a = a + 1000; // doesn't compile, because an int cannot be assigned to a byte.