Bitwise and Shift Operators in Java

Bitwise operators work on the binary representation of integers. They let you pack multiple booleans into a single int, check individual bits, and multiply or divide by powers of two without multiplication.

The operators

Flags as bitmasks

static final int READ    = 1 << 0;    // 0001
static final int WRITE   = 1 << 1;    // 0010
static final int EXECUTE = 1 << 2;    // 0100

int perms = READ | WRITE;

boolean canRead = (perms & READ) != 0;   // set?
perms |= EXECUTE;                          // add flag
perms &= ~WRITE;                           // clear flag
perms ^= READ;                             // toggle

For type-safe flags, prefer EnumSet — it's backed by bitmasks internally but keeps the code readable.

Sign-preserving vs zero-fill shift

int n = -8;                      // 11111111_11111111_11111111_11111000
n >>  1;                         // -4        — sign bit copied
n >>> 1;                         // 2147483644 — leading zero

Use >>> when you want to treat the value as unsigned (e.g. reading hashes, bit manipulation).

Fast math

x << n;          // x * 2ⁿ
x >> n;          // x / 2ⁿ (rounding toward negative infinity)
x & (m - 1);     // x mod m — when m is a power of 2

These micro-optimisations rarely matter — modern JITs do them for you. Readability usually wins.

Precedence trap

if (x & MASK == 0) { ... }       // ❌ parses as x & (MASK == 0)
if ((x & MASK) == 0) { ... }     // ✅ always parenthesise

Common mistakes

• Mixing & and && — & is bitwise; && is short-circuit logical.
• Shifting by ≥ 32 on an int — the shift count is taken modulo 32. 1 << 32 == 1, not 0.
• Forgetting parentheses — & has lower precedence than ==.

Related

Pillar: Java operators. See also int, enum (for EnumSet).