Java Operators: A Practical Summary

This page consolidates arithmetic, bitwise/shift, logical, comparison, assignment, ternary, and cast operators into a single, cohesive reference. Examples compile on modern Java (LTS or feature releases) and highlight gotchas such as short-circuiting, integer division, numeric promotion, and reference equality vs. value equality.

Arithmetic operators

Unary: + (no-op sign), - (negation), ++, --. Binary: +, -, *, /, %. With integers, division truncates toward zero; remainder (%) keeps the dividend’s sign. The + operator also concatenates String values.

Prefix vs. postfix

++x increments then yields the new value; x++ yields current value then increments. Same idea for --.

Bitwise and shift operators

Operate on integer types only: ~ (bitwise NOT), & (AND), | (OR), ^ (XOR), shifts <<, >> (arithmetic right, sign-extending), and >>> (logical right, zero-extending).

Bitwise demo

public class BitwiseDemo {
  public static void main(String[] args) {
    System.out.println(~3);        // -4
    System.out.println(3 & 5);     // 1
    System.out.println(3 | 4);     // 7
    System.out.println(5 ^ 4);     // 1
    System.out.println(3 << 3);   // 24
    System.out.println(-6 >> 2);   // -2
    System.out.println(6 >>> 2);   // 1
  }
}

Boolean logical operators

These operate only on boolean: non-short-circuit &, |, ^, logical NOT !, and short-circuit &&, ||. Prefer short-circuiting in conditionals to avoid needless evaluation (and side effects).

int a = 10, b = 20;
System.out.println(a > 20 && b > 10); // false (first term false)
System.out.println(a > 20 || b > 10); // true  (second term true)
System.out.println(!(b > 10));        // false
System.out.println(!(a > 20));        // true

Comparison and type-test operators

Relational: <, <=, >, >=. Equality: ==, !=. Type test: instanceof.

• Primitives: ==/!= compare values.
• References: ==/!= compare object identity. Use equals() for value equality (e.g., String).
• Pattern matching (newer Java): if (obj instanceof String s) { ... } safely narrows the type.

Assignment and compound assignment

Simple assignment = plus compound forms: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, >>>=.

• Numeric promotion: short s = 1; s += 1; compiles (with implicit cast). s = s + 1; requires an explicit cast.
• Assignment is an expression; avoid writing conditions that rely on it (readability suffers).

Ternary (conditional) operator

Form: condition ? whenTrue : whenFalse. Result types must be compatible or one convertible to the other.

int x = 7;
String parity = (x % 2 == 0) ? "even" : "odd";

Cast operator and conversions

(type) performs explicit conversion. Widening (e.g., int → long) is safe; narrowing (e.g., int → short) may overflow/truncate.

long big = 3_000_000_000L;
int narrowed = (int) big; // overflow: value wraps per two’s complement

Precedence & associativity (abridged)

From high → low: (), unary (+ - ! ~ ++ --), multiplicative (* / %), additive (+ -), shifts, relational (< <= > >= instanceof), equality (== !=), bitwise AND &, XOR ^, OR |, logical AND &&, logical OR ||, ternary ? :, assignment.

Use parentheses to document intent and avoid precedence mistakes.

Quick check (reads as true/false)

System.out.println( (3 / 2) * 2 == 3 );       // false (integer truncation)
System.out.println( "a" + 1 + 2 );            // "a12" (left-to-right, String first)
System.out.println( 1 + 2 + "a" );            // "3a" (numbers first, then String)
System.out.println( (null instanceof Object) ); // false
System.out.println( true & f());              // f() called (non-short-circuit)
System.out.println( true && f());             // f() called; left is true, must check right

static boolean f() { System.out.println("side-effect"); return true; }

Common pitfalls

• == vs equals(): use equals() for value equality of objects (e.g., String).
• Short-circuiting: prefer &&/|| over &/| in boolean logic to avoid unintended side effects.
• Integer math: remember truncation; use double/BigDecimal when appropriate.
• Shifts on negatives: >> sign-extends, >>> zero-extends.
• Compound assignment: implicit casts can hide narrowing—be explicit when clarity matters.