Logical AND

The && operator is the logical AND operator in Kotlin. It performs a strict boolean conjunction, evaluating to true if and only if both its left and right operands evaluate to true. If either operand is false, the entire expression evaluates to false.

val result = expression1 && expression2

Technical Characteristics

Type Constraints Both operands provided to the && operator must resolve to the Boolean type. The resulting evaluation also strictly returns a Boolean. Kotlin does not support implicit truthiness (e.g., evaluating non-zero integers or non-empty strings as true); operands must be explicit booleans.

Short-Circuit Evaluation Kotlin implements short-circuit (lazy) evaluation for the && operator. The evaluation proceeds strictly from left to right. If the left-hand operand evaluates to false, the overall expression is mathematically guaranteed to be false. In this scenario, the Kotlin compiler entirely bypasses the evaluation of the right-hand operand.

// If `conditionA` is false, `functionB()` is never executed.
val result = conditionA && functionB()

This behavior is structurally critical as it prevents side effects, state mutations, or runtime exceptions (such as NullPointerException or IndexOutOfBoundsException) that might otherwise occur if the right-hand expression were forced to evaluate.

Operator Precedence In Kotlin’s hierarchy of operations, the && operator is evaluated after most other operators, but before logical OR and assignment. Specifically, its precedence is:

• Lower than: Logical NOT (!), comparison operators (<, >, <=, >=), and equality operators (==, !=).
• Higher than: Logical OR (||) and assignment operators (=, +=, etc.).

// Evaluated as: (!isReady) && (count > limit)
val result = !isReady && count > limit 

No Operator Overloading Unlike many mathematical and structural operators in Kotlin (such as +, -, or ==), the && operator cannot be overloaded. Because short-circuiting dictates control flow rather than just value transformation, the compiler must maintain absolute control over its execution path.

If strict evaluation of both operands is required regardless of the left operand’s state, Kotlin provides the and infix function (Boolean.and(Boolean)), which performs a logical AND without short-circuiting.

Master Kotlin with Deep Grasping Methodology!

Learn More