> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java 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.
```java theme={"dark"}
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`.
```java theme={"dark"}
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.
```java theme={"dark"}
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.
```java theme={"dark"}
Integer val = 100;
val -= 25; // Unboxes 'val' to int, subtracts 25, re-boxes 75 into 'val'.
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
