Bitwise AND Assignment

The &= operator is a compound assignment operator that performs a bitwise AND (for integral types) or a logical AND (for boolean types) operation between the left and right operands, assigning the computed result back to the left operand.

Syntax and Evaluation

variable &= expression;

Internally, the Java compiler evaluates a &= b as a = (T) (a & b), where T is the declared data type of a. This includes an implicit narrowing primitive conversion, which prevents compilation errors when operating on types smaller than int (such as byte, short, or char) that are automatically promoted to int during bitwise operations.

Crucially, Java semantics dictate that the left-hand operand in a compound assignment is evaluated exactly once. This distinguishes a &= b from its expanded form a = (T) (a & b) when the left operand contains side effects. For example, the expression arr[i++] &= b evaluates the array access and increments i only once, whereas arr[i++] = (T) (arr[i++] & b) would evaluate the array access and increment i twice.

Behavior by Data Type

1. Integral Types (byte, short, int, long, char) When applied to integral types, &= performs a bit-by-bit comparison of the binary representations of both operands. A bit in the resulting value is set to 1 if and only if the corresponding bits in both operands are 1. Otherwise, the resulting bit is 0.

int a = 12;  // Binary representation: 0000 1100
int b = 10;  // Binary representation: 0000 1010

a &= b;      // Bitwise AND operation
             // 0000 1100
             // 0000 1010
             // ------
             // 0000 1000 (Decimal: 8)
             
// a is now 8

2. Boolean Type (boolean) When applied to boolean variables, &= performs a strict logical AND operation. The left operand is assigned true if and only if both the initial value of the left operand and the evaluated right operand are true. Otherwise, it is assigned false.

Unlike the conditional AND operator (&&), the &= operator does not short-circuit. The right-hand expression is always evaluated, regardless of the initial state of the left-hand operand.

boolean flag = false;

// The method evaluateCondition() WILL be executed even though flag is already false.
flag &= evaluateCondition(); 

Implicit Casting Mechanics

Because compound assignment operators automatically cast the result back to the left operand’s type, &= bypasses the explicit casting requirement that a standard & operation would demand when working with narrower primitive types.

byte b1 = 12;
byte b2 = 10;

// Standard bitwise AND requires explicit casting because operands are promoted to int
// b1 = b1 & b2; // Compilation error: incompatible types: possible lossy conversion from int to byte
b1 = (byte) (b1 & b2); // Compiles

// Compound assignment handles the cast implicitly
b1 &= b2; // Compiles successfully

Master Java with Deep Grasping Methodology!

Learn More