Subtraction Assignment

The -= operator is a compound assignment operator in Java that subtracts the value of the right operand from the left operand and assigns the resulting value back to the left operand.

leftOperand -= rightOperand;

Under the Java Language Specification (JLS), the expression E1 -= E2 is formally equivalent to E1 = (T) ((E1) - (E2)), where T is the declared data type of E1.

Technical Mechanics

1. Implicit Type Casting The most critical characteristic of the -= operator is its inclusion of an implicit narrowing primitive conversion. If the evaluation of the subtraction results in a wider data type than the left operand, the compiler automatically casts the result back to type T.

byte b = 10;
b -= 5.5; // Compiles successfully. 
          // Equivalent to: b = (byte) (b - 5.5);
          // Result is 4 (fractional part is truncated).

Attempting the standard assignment equivalent (b = b - 5.5;) would result in a compilation error due to a lossy conversion from double to byte.

2. Single Evaluation The left operand (E1) is evaluated only once. This distinction is important when the left operand involves a method call or an array access with side effects.

int[] arr = {10, 20, 30};
int index = 1;

// 'index++' is evaluated only once.
arr[index++] -= 5; 
// arr[1] becomes 15. 'index' becomes 2.

3. Type Compatibility The -= operator is strictly defined for numeric types. Both operands must be convertible to primitive numeric types (byte, short, char, int, long, float, double).

It also supports reference types that are wrapper classes for numeric primitives (e.g., Integer, Double, Byte). In these instances, Java performs automatic unboxing to extract the primitive value, executes the subtraction, and then re-boxes the result if the left operand is a wrapper class.

Integer val = 100;
val -= 25; // Unboxes 'val' to int, subtracts 25, re-boxes 75 into 'val'.

Master Java with Deep Grasping Methodology!

Learn More