Not-Null Assertion

The !! operator, formally known as the not-null assertion operator, converts a nullable type (T?) to its corresponding non-nullable type (T). It instructs the Kotlin compiler to bypass its standard static null-safety checks, throwing a NullPointerException (NPE) at runtime if the operand evaluates to null. Unlike the as or as? operators, which perform actual type casting, !! is strictly an assertion and compile-time type conversion mechanic.

Syntax and Type Resolution

The operator is applied as a postfix to an expression.

val nullableValue: String? = "Kotlin"
val strictValue: String = nullableValue!!

From a type-system perspective, if e is an expression of type T?, the expression e!! is resolved by the compiler as type T. This type conversion allows the resulting value to be assigned to non-nullable variables, passed as non-nullable arguments, or used as a receiver for properties and functions that strictly reject nulls.

Runtime Evaluation

Unlike Swift’s Optionals or Java’s Optional, Kotlin’s nullable reference types (like String?) are not wrapper objects. At runtime, a nullable reference is the exact same memory reference as a non-nullable one. The !! operator merely performs a null check; there is no “unwrapping” involved (except when unboxing nullable primitives like Int?).

When the target runtime executes the !! operator, it performs a strict equality check against null:

1. Non-null operand: The operator returns the existing memory reference, allowing execution to proceed.
2. Null operand: The operator immediately halts execution of the current statement and throws a NullPointerException.

var name: String? = null
// The !! operator evaluates 'name'. 
// Because it is null, an NPE is thrown before '.length' is ever accessed.
val length: Int = name!!.length 

Chaining Mechanics

When multiple not-null assertions are chained within a single expression, they are evaluated strictly from left to right.

class Node(val value: String?, val left: Node?)

val node: Node? = Node("Root", Node(null, null))

// Evaluates left-to-right. Throws NPE at .value!! because left.value is null.
val result: String = node!!.left!!.value!!

In this expression:

• If node is null, the NPE is thrown immediately at node!!.
• The subsequent property accesses (.left, .value) and their respective assertions are never evaluated due to the immediate exception dispatch.
• If an NPE occurs, the stack trace will point to the specific line containing the chain, though the exception itself originates directly from the specific !! operator that encountered the null value.

Idiomatic Usage and Alternatives

In Kotlin, using the !! operator is generally discouraged and is widely considered a code smell. Because it intentionally subverts the language’s null-safety guarantees, it introduces the risk of unhandled runtime crashes. Developers should prefer safer, more idiomatic alternatives for handling nullability:

• Safe call operator (?.): Executes the subsequent call only if the receiver is not null.
• Elvis operator (?:): Provides a fallback or default value if the expression to its left resolves to null.
• requireNotNull() or checkNotNull(): Standard library functions that assert non-nullability but throw IllegalArgumentException or IllegalStateException with descriptive, custom error messages instead of a generic NPE.

Master Kotlin with Deep Grasping Methodology!

Learn More