Multiplication Assignment

The *= operator is a compound assignment operator in Java that multiplies the current value of the left-hand operand by the value of the right-hand expression, subsequently assigning the computed product back to the left-hand operand.

Syntax

variable *= expression;

Mechanics and Equivalence

At a basic level, the operator serves as syntactic sugar. The expression a *= b is conceptually equivalent to a = a * b. However, the Java Language Specification (JLS) dictates a critical distinction regarding type conversion.

Formally, if E1 is the left-hand operand of type T, and E2 is the right-hand operand, the compound assignment E1 *= E2 is equivalent to:

E1 = (T) ((E1) * (E2));

Implicit Narrowing Conversion

The most significant technical characteristic of the *= operator is its inclusion of an implicit cast to the type of the left-hand operand. When performing standard arithmetic operations (like *), Java automatically promotes integral types smaller than int (such as byte, short, or char) to int.

Using the standard assignment operator requires an explicit cast to avoid a compilation error, whereas the *= operator handles this cast automatically at the compiler level.

byte a = 10;
byte b = 5;

// Standard multiplication requires an explicit cast
// a = a * b; // COMPILATION ERROR: incompatible types: possible lossy conversion from int to byte
a = (byte) (a * b); // Compiles successfully

// Compound assignment handles the cast implicitly
a *= b; // Compiles successfully. Equivalent to: a = (byte) (a * b);

Evaluation Order

When using the *= operator, the left-hand operand is evaluated exactly once. This is a crucial distinction when the left-hand operand contains an expression with side effects, such as a method call or a complex array index calculation.

// The method getIndex() is executed exactly once.
array[getIndex()] *= 2; 

// In the expanded version, getIndex() would be executed twice.
array[getIndex()] = array[getIndex()] * 2; 

Type Compatibility

The *= operator can only be applied to primitive numeric types (byte, short, char, int, long, float, double) and their corresponding wrapper classes (via unboxing). It cannot be applied to boolean or reference types (such as String or Object).

Master Java with Deep Grasping Methodology!

Learn More