Assignment in Java: Simple and Compound Assignment Operators

An assignment operator stores a value into a variable. The one you already use is =, called the simple assignment operator. It reads "put the value on the right into the box named on the left".

x = 25;
+-----------+ +---------+ | x |

Two ideas are bundled into that one symbol, and both cause confusion later.

• It is a **store**, not a copy of the value itself. For int the value is genuinely copied. For an object you copy the reference, so both variables then point at the same object.

• = is not "equals". That is ==. Writing = where you meant == is the single most common typo in Java, and the compiler usually catches it with a message like *unexpected type* or *not a statement*.

= is used in two places that look identical but are not quite the same thing.

int count = 5;
// DECLARATION and initialisation: a new variable
count = 6;
// ASSIGNMENT: storing into a variable that already exists

The first creates a variable and gives it a value in one step. The second replaces the value of a variable that already exists. From the compiler's point of view both are assignment, which is why the JLS calls = the simple assignment operator and treats the declaration form as a special case of it.

int a, b, c;
// declare three variables, all defaulting to 0
a = b = c = 10;
// assignment is right-to-left, so all three become 10

• The variable must already be declared. Java has no dynamic creation, unlike Python.

• The type must match. A String variable cannot be given an int, and an int cannot be given a String, with no implicit conversion between them.

• A local variable must be initialised before it is read. The compiler will not let you use a local int before you assign it. Fields are different: they silently default to 0, false or null.

A compound operator does an operation and stores the result in one step. Each one is shorthand for a longer statement, with one important exception covered in the next section.

+= has a second job that catches people out. If the variable is a String, the right-hand side is concatenated rather than added.

String s = "Hello";
s += ", ";
// s is now "Hello, "
s += "Java";
// s is now "Hello, Java"
int n = 5;
n += 1;
// n is now 6, real addition

String concatenation is covered in detail in the String topic, but the rule to remember here is simply: if the left variable is a String, += means append.

This is the single most tested fact about assignment in Java, and the original version of this page stated it in a way that was true but easy to misread. Here is the precise behaviour.

byte b = 1;
b = b + 2;
// ERROR: incompatible types: possible lossy conversion from int to byte
b += 2;
// FINE: b is 3

The two lines look identical but behave differently, and here is why.

```text
b = b + 2

b : byte --> 1 (int)

so the compiler refuses ERROR: possible lossy conversion

b += 2

The cast is really there. `javap -c` on `b += 2` shows the arithmetic happening as `int` and then a narrowing `i2b` instruction to squeeze the result back into the byte.

This applies to +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, |= and ^=` alike. It is the reason compound assignment is not simply a shorthand.

Because the cast is automatic, nothing warns you when the result does not fit. Java narrows by discarding digits, and it does so without any complaint at all.

public class Truncation {
    public static void main(String[] args) {
        byte c = 1;
        c *= 300;
        // 1 * 300 = 300, which does not fit in a byte
        System.out.println("byte c = 1; c *= 300;  -> c = " + c);
        int i = 1;
        i += 2.7;
        // 1 + 2.7 = 3.7, truncated to 3
        System.out.println("int i = 1; i += 2.7;    -> i = " + i);
        int x = 5;
        x /= 2.0;
        // a double on the right, an int on the left
        System.out.println("int x = 5; x /= 2.0;    -> x = " + x);
        short s = 32767;
        s += 1;
        // overflow wraps silently
        System.out.println("short 32767 + 1         -> s = " + s);
        int big = Integer.MAX_VALUE;
        big += 1;
        System.out.println("Integer.MAX_VALUE + 1  -> " + big);
    }
}

The real output:

byte c = 1;
c *= 300;
-> c = 44 int i = 1;
i += 2.7;
-> i = 3 int x = 5;
x /= 2.0;
-> x = 2 short 32767 + 1 -> s = -32768 Integer.MAX_VALUE + 1 -> -2147483648

Line by line, these are the rules:

• c *= 300 computes 300, which does not fit in a byte, so it wraps to 300 minus 256, which is 44.

• i += 2.7 promotes to double, adds to get 3.7, then casts back to int and truncates towards zero, giving 3. The .7 is simply discarded.

• x /= 2.0 divides as a double to get 2.5, then narrows to int and truncates to 2. Had you written x /= 2 the result would also be 2, but for a different reason.

• Adding 1 to short overflows, and adding 1 to Integer.MAX_VALUE overflows a 32-bit int. Both wrap silently. Overflow is **never** an exception in Java; it just produces a wrong number.

If silent truncation is a real risk, use Math.toIntExact or do the arithmetic in a wider type on purpose:

long count = 5_000_000_000L;
// 5 billion, far past the int range
int silently =(int) count;
// legal cast, silently gives 705032704
System.out.println("(int) count = " + silently);
// a wrong number, no warning
int safe = Math.toIntExact(count);
// throws ArithmeticException

(int) count = 705032704 Math.toIntExact throws: ArithmeticException

The same idea exists for long in Math.addExact and Math.multiplyExact, and both are worth reaching for whenever a number comes from outside your program.

x += y is not simply a rewrite into x = x + y when the left side is an array element. Java evaluates the target once, then both reads and writes that same location. That is why this is safe and the naive rewrite is not.

public class EvaluatedOnce {
    static int[] values = {
        10, 20, 30
    };
    static int index = 1;
    public static void main(String[] args) {
        values[index] += 5;
        // 20 becomes 25
        System.out.println("values[1] is now " + values[1]);
        System.out.println("index is now " + index);
    }
}

The rule matters when the index is a method call or any expression with a side effect, because the value is computed exactly once.

public class Once {
    static int[] a = {
        10, 20, 30
    };
    static int calls = 0;
    static int idx() {
        calls++;
        return 1;
    } public static void main(String[] args) {
        a[idx()] += 5;
        // idx() is called exactly ONCE
        System.out.println("a[1] = " + a[1] + ", idx() called " + calls + " time(s)");
    }
}

a[1] = 25, idx() called 1 time(s)

If you rewrote this by hand as a[idx()] = a[idx()] + 5; then idx() would run twice, which matters whenever it costs money, logs something, or returns a different value each time.

Assignment chains group from the right. The expression a = b = c = 10 means "assign 10 to c, then to b, then to a".

a = b = c = 10 step 1: c = 10 step 2: b =(c = 10) b becomes 10 step 3: a =(b = c = 10) a becomes 10 all three end up as 10

= has the **lowest precedence** of any Java operator, so everything to the right is grouped before the assignment happens.

int m, n;
m = n = 2 + 3 * 4;
// * first: 2 + 12 = 14, then m and n both become 14

This is not (2 + 3) * 4. If you want the sum first you must parenthesise it, which is exactly why a calculator that forgets its brackets gives the wrong answer.

Because an assignment is itself an expression, it has a value, and you can use that value.

int total = 0;
int doubled =(total = 21) * 2;
// total becomes 21 first, then 21 * 2 = 42

• The value of a = b is the value that was stored.

• In C and C++ the value of an assignment is a constant you cannot assign to. In Java it is a normal variable, so a = b = c is normal code, not a trick.

• Assignment and == are easy to confuse, and the mistake produces confusing errors such as *unexpected type*.

The bitwise family has compound forms too, and they follow the same "operate then store" rule as arithmetic.

public class BitwiseAssign {
    public static void main(String[] args) {
        int x = 5;
        x >= 2;
        System.out.println("-8 >>= 2   -> " + y);
        // -2, keeps the sign
        int z = -1;
        z >>>= 1;
        System.out.println("-1 >>>= 1  -> " + z);
        // 2147483647, no sign
        System.out.println("            (>>> fills with zeros, so a negative int becomes large positive)");
        int w = 12;
        w &= 10;
        System.out.println("12 &= 10   -> " + w);
        // 8   1100 & 1010
        int v = 12;
        v |= 3;
        System.out.println("12 |= 3    -> " + v);
        // 15  1100 | 0011
        int u = 12;
        u ^= 10;
        System.out.println("12 ^= 10   -> " + u);
        // 6   1100 ^ 1010
    }
}

&=, |= and ^= also work on booleans, where they mean and, or and xor.

boolean p = true, q = false;
p &= q;
System.out.println("true &= false  -> " + p);
// false
p |= q;
System.out.println("false |= false -> " + p);
// false
p ^= true;
System.out.println("false ^= true  -> " + p);
// true

Note the two right shifts. >>= keeps the sign bit, so -8 becomes -2, while >>>= shifts in zeros, so -1 becomes 2147483647. The full bitwise story is in the bitwise computing topic.

Not everything on the left of = is a variable, and Java rejects several things that look assignable.

final int f = 1;
f = 2;
// ERROR: cannot assign a value to final variable f
f += 1;
// ERROR: same thing, += is an assignment too
int[] n = {
    1, 2
};
n.length = 5;
// ERROR: cannot assign a value to final variable length

• A final variable cannot be assigned after its initial assignment, whether you use = or a compound operator. Both are assignments as far as the compiler is concerned.

• array.length is final by design, so it can never be changed.

• Method call results, literals and the result of an expression are values, not places to store things, so they cannot be assigned to.

Assignment to a field, a method parameter or an array element is perfectly legal, and this is worth contrasting with Topic 20, where a note claimed that a final variable could still be "reassigned" by writing discount = discount - 1. It cannot. That line is a reassignment, and if discount is final the compiler rejects it. The same topic's snippet called that line "not a reassignment", which is simply wrong.

public class FinalIsFinal {
    public static void main(String[] args) {
        final int discount = 10;
        // discount = 20;                 // ERROR: final cannot be reassigned
        // discount = discount - 1;       // ERROR: still a reassignment
        int price = 100;
        // not final, so this is fine
        price = price - 1;
        // a reassignment, and perfectly legal
        System.out.println("price = " + price);
    }
}

Assignment looks like one operator but is really two families. The simple = stores a value and has the lowest precedence in the language, while the compound operators are shorthands that quietly insert a cast back to the left-hand type. That cast is the reason b += 2 compiles when b = b + 2 does not, and it is also the reason a byte can wrap to 44 and an int can overflow without a single warning.