Home » Java » Java's +=, -=, *=, /= compound assignment operators

Java's +=, -=, *=, /= compound assignment operators

Posted by: admin November 2, 2017 Leave a comment

Questions:

Until today, I thought that for example:

i += j;

is just a shortcut for:

i = i + j;

But what if we try this:

int i = 5;
long j = 8;

Then i = i + j; will not compile but i += j; will compile fine.

Does it mean that in fact i += j; is a shortcut for something like this
i = (type of i) (i + j)?

Answers:

As always with these questions, the JLS holds the answer. In this case §15.26.2 Compound Assignment Operators. An extract:

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.

An example cited from §15.26.2

[…] the following code is correct:

short x = 3;
x += 4.6;

and results in x having the value 7 because it is equivalent to:

short x = 3;
x = (short)(x + 4.6);

In other words, your assumption is correct.

Questions:
Answers:

A good example of this casting is using *= or /=

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

or

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

or

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

or

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Questions:
Answers:

Very good question. The Java Language specification confirms your suggestion.

For example, the following code is correct:

short x = 3;
x += 4.6;

and results in x having the value 7 because it is equivalent to:

short x = 3;
x = (short)(x + 4.6);
Questions:
Answers:

Yes,

basically when we write

i += l; 

the compiler converts this to

i = (int)(i + l);

I just checked the .class file code.

Really a good thing to know

Questions:
Answers:

you need to cast from long to int explicitly in case of i = i + l then it will compile and give correct output. like

i = i + (int)l;

or

i = (int)((long)i + l); // this is what happens in case of += , dont need (long) casting since upper casting is done implicitly.

but in case of += it just works fine because the operator implicitly does the type casting from type of right variable to type of left variable so need not cast explicitly.

Questions:
Answers:

The problem here involves type casting.

When you add int and long,

  1. The int object is casted to long & both are added and you get long object.
  2. but long object cannot be implicitly casted to int. So, you have to do that explicitly.

But += is coded in such a way that it does type casting. i=(int)(i+m)

Questions:
Answers:

In Java type conversions are performed automatically when the type of the expression on the right hand side of an assignment operation can be safely promoted to the type of the variable on the left hand side of the assignment. Thus we can safely assign:

 byte -> short -> int -> long -> float -> double. 

The same will not work the other way round. For example we cannot automatically convert a long to an int because the first requires more storage than the second and consequently information may be lost. To force such a conversion we must carry out an explicit conversion.
Type – Conversion

Questions:
Answers:

Sometimes, such a question can be asked at an interview.

For example, when you write:

int a = 2;
long b = 3;
a = a + b;

there is no automatic typecasting. In C++ there will not be any error compiling the above code, but in Java you will get something like Incompatible type exception.

So to avoid it, you must write your code like this:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

Questions:
Answers:

The main difference is that with a = a + b, there is no typecasting going on, and so the compiler gets angry at you for not typecasting. But with a += b, what it’s really doing is typecasting b to a type compatible with a. So if you do

int a=5;
long b=10;
a+=b;
System.out.println(a);

What you’re really doing is:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Questions:
Answers:

Subtle point here…

There is an implicit typecast for ‘i+j’ when ‘j’ is a double and ‘i’ is an int.
Java ALWAYS converts an integer into a double when there is an operation between them.

To clarify ‘i+=j’ where i is an integer and j is a double can be described as

i = <int>(<double>i + j)

See: this description of implicit casting

You might want to typecast j to (int) in this case for clarity.

Questions:
Answers:

In the case of compound assignment operator, internal type casting will be performed automatically:

byte b1 = 10;
//b1 = b1 + 1; Compile time error because found int
System.out.println(b1);
byte b3 = 10;
b3 += 1; //in compound assignment implicit type casting will be performed simultaneously
System.out.println("b3=: "+b3);
byte b4 = 127;
b4 += 3; //in compound assignment implicit type casting will be performed simultaneously
System.out.println("b4=: "+b4);//-126

And in some cases, you will lose some values:

int i = 1;
i += 1.5;
System.out.println("i=: "+i); //will print 2, and you lost .5 !!!