skip to content

What does the ^ operator do when both operands are boolean, and when is logical XOR useful?

level: middleimportance: should knowfreq 40%

answer

  1. ^ on booleans = XOR = true when they DIFFER
  2. a ^ b is the same as a != b (booleans)
  3. Cannot short-circuit; both sides always evaluated
  4. Use for 'exactly one' / mutual exclusion
  5. On integers ^ is bitwise XOR; ^ is NOT exponent

basics

~20 s

On two booleans, ^ is logical XOR (exclusive or): it is true when the two values are different, and false when they are the same. It's handy to test 'exactly one of these is true'.

solid answer

~40 s

When both operands are boolean, `^` is logical XOR — exclusive OR. It returns true exactly when the two operands differ (one true, one false) and false when they match. Equivalently, `a ^ b` is the same as `a != b` for booleans. Unlike `&&`/`||`, XOR cannot short-circuit: knowing one operand never determines the result, so both operands are always evaluated. A common use is enforcing a 'mutually exclusive' rule — exactly one of two flags must be set — e.g. `if (useCache ^ useDb)`. Another is toggling a boolean (`flag ^= true` flips it). On integral types `^` is bitwise XOR instead, combining bits where exactly one is set. People sometimes write `a != b` for booleans because it reads more clearly than `^`, and that's perfectly fine since they're equivalent.

code

java · 16 lines
java
boolean useCache = true;
boolean useDb = false;

boolean exactlyOne = useCache ^ useDb;   // true (they differ)
boolean same       = useCache ^ useCache; // false (identical)

// equivalent to !=
System.out.println((useCache ^ useDb) == (useCache != useDb)); // true

// toggling
boolean flag = false;
flag ^= true;   // now true
flag ^= true;   // now false again

// integer (bitwise) meaning, for contrast:
int n = 5 ^ 3;  // 0101 ^ 0011 = 0110 = 6

go deeper

for a junior

Recognizes ^ as XOR and that true^false is true; may rely on the != equivalence to reason about it.

for a middle

Explains the full truth table, the a != b equivalence, no short-circuiting, and a real 'exactly one' use case.

for a senior

Knows the integer/bitwise overload, precedence (& > ^ > |), toggling idioms, and when != reads better than ^.

for a principal

Decides team style on ^ vs. != for readability, and recognizes bitwise-XOR identities (x^x=0) where genuinely useful versus obscure.

## XOR — exclusive or **XOR** (exclusive OR), written `^`, means "one or the other, but not both". For two booleans `a` and `b`: ``` A B A ^ B false false false (same → false) false true true (different → true) true false true (different → true) true true false (same → false) ``` The rule to memorize: **`a ^ b` is true exactly when `a` and `b` differ.** Compare with regular OR (`|`/`||`), which is true when *at least one* is true (including both true). XOR excludes the both-true case — that's the "exclusive" part. ## The handy equivalence For booleans, `a ^ b` is exactly the same as `a != b` ("a is not equal to b"). Many developers prefer writing `a != b` because it reads more naturally; both compile to the same logic. Likewise `!(a ^ b)` equals `a == b`. ## No short-circuiting `&&` and `||` can short-circuit because one operand can fix the result (`false && x` is always false). For XOR, **neither operand alone ever determines the result** — you must know both to decide if they differ. Therefore `^` **always evaluates both operands**; there is no `^^` operator, and short-circuiting would be impossible anyway. ## Useful applications **1. Mutual exclusion — "exactly one".** When a configuration requires precisely one of two options: ```java if (!(useCache ^ useDb)) { throw new IllegalStateException("Set exactly one of useCache / useDb"); } ``` Here `useCache ^ useDb` is true only when exactly one is set; negating it catches the both-or-neither error cases. **2. Toggling a flag.** `flag ^= true;` flips a boolean (true→false, false→true). It's a compact alternative to `flag = !flag;` (the latter is usually clearer). **3. Parity / difference checks.** Any time the question is literally "are these two truth values different?", XOR expresses it directly. ## Bitwise XOR on integers Like `&`/`|`, the `^` symbol is overloaded: on integral types it's **bitwise XOR**, combining numbers bit-by-bit where exactly one bit is set. `5 ^ 3` is `6` (`0101 ^ 0011 = 0110`). A classic property: `x ^ x == 0` and `x ^ 0 == x`, which underlies tricks like swapping two ints without a temp (rarely worth it today). This question is about the **boolean** meaning, but knowing the symbol is shared avoids confusion. ## Precedence Among `&`, `^`, `|`, precedence is `& > ^ > |`, and all of them bind tighter than `&&` and `||`. In mixed expressions, parenthesize to be safe. ## Common confusion to avoid - `^` is **not** "power" in Java (no exponent operator exists; use `Math.pow`). - `^` on booleans is **not** the same as `||`: `true ^ true` is `false`, but `true || true` is `true`.

  • Why is there no ^^ short-circuit operator like && and ||?
    Short-circuiting needs one operand to determine the result. For XOR, neither operand alone fixes the outcome — you must evaluate both — so a short-circuit version is impossible and pointless.
  • Rewrite useCache ^ useDb without ^.
    useCache != useDb — for booleans, XOR and != are identical.

XOR is a seesaw: it's 'up' (true) only when the two ends are at different heights. If both kids are up, or both are down (same), the seesaw is level (false).

saying these in an interview costs you the question

  • Saying ^ means exponentiation (it does not in Java)
  • Treating boolean ^ like || (forgetting both-true yields false)
  • Claiming ^ can short-circuit
  • Confusing bitwise ^ on ints with logical ^ on booleans

context

resolving links…