Skip to main content

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.

The -- operator is a unary arithmetic decrement operator in Java that reduces the value of a numeric variable by exactly one. It mutates the operand in place and is applicable to all primitive numeric types (byte, short, int, long, float, double), the char type, and their corresponding boxed wrapper classes. The operator operates in two distinct modes depending on its placement relative to the operand: prefix and postfix.

​
Prefix Decrement (--operand)

In prefix mode, the decrement operation occurs before the value is evaluated in the enclosing expression. The expression evaluates to the newly decremented value. 
int x = 5;
int y = --x; 

// Execution order:
// 1. x is decremented to 4.
// 2. y is assigned the new value of x (4).
// Final state: x = 4, y = 4

​
Postfix Decrement (operand--)

In postfix mode, the current value of the operand is evaluated and temporarily stored for use in the enclosing expression before the decrement operation is applied to the variable. 
int a = 5;
int b = a--; 

// Execution order:
// 1. The original value of a (5) is evaluated for the assignment.
// 2. a is decremented to 4.
// 3. b is assigned the evaluated original value (5).
// Final state: a = 4, b = 5

​
Technical Characteristics

Implicit Type Casting The -- operator automatically performs an implicit narrowing primitive conversion. For an operand E of type T, the operation E-- or --E is functionally equivalent to E = (T)(E - 1). This prevents compilation errors when working with narrower types like byte or short that would otherwise undergo numeric promotion to int. 
byte b = 10;
b--;        // Compiles successfully. Implicitly executes: b = (byte)(b - 1);
b = b - 1;  // Compilation error: incompatible types (int cannot be converted to byte).
Bytecode Translation and Non-Atomicity Despite its concise syntax, the -- operator is not an atomic operation, and its bytecode translation varies based on the operand’s scope and type:
  • Local int variables: The compiler optimizes the decrement into a single iinc (integer increment by constant) bytecode instruction. This modifies the value directly in the local variable array without loading it onto the operand stack.
  • Fields and Array Elements: For instance variables, static fields, or array elements, the operation compiles to a multi-instruction read-modify-write sequence. For example, decrementing an instance field involves loading the object reference (aload), reading the field (getfield), pushing the constant 1 (iconst_1), subtracting (isub), and writing the result back (putfield).
Regardless of whether it compiles to a single iinc instruction or a multi-instruction sequence, the -- operator is not atomic at the CPU level. It is not thread-safe when applied to shared variables in a multithreaded environment. Concurrent access requires external synchronization or the use of atomic classes (e.g., AtomicInteger). Floating-Point Behavior When applied to float or double operands, the operator subtracts 1.0. It strictly adheres to IEEE 754 arithmetic standards. Consequently, applying -- to NaN results in NaN, and applying it to Positive Infinity or Negative Infinity leaves the value unchanged.
Master Java with Deep Grasping Methodology!Learn More