Kotlin's type system is built to eliminate NullPointerException (NPE) occurrences from application code by default. NPEs can only appear in the following explicit edge cases:

• Deliberate calls to throw NullPointerException()
• Usage of the non-null assertion !! operator
• Inconsistent state during object initialization, such as:
  • Leaking an uninitialized this reference from a constructor to external code
  • A superclass constructor invoking an open member that accesses uninitialized state in the derived class implementation
• Java interoperability scenarios:
  • Attempting to access a member of a null platform type reference
  • Generic type nullability mismatches with Java code, e.g. Java code adding a null entry to a Kotlin MutableList<String> that was assumed to only hold non-null values (you should use MutableList<String?> for such cases)
  • Other unexpected null values originating from external Java code

Kotlin's type system explicitly differentiates between references that can hold null (nullable references) and those that cannot (non-null references). For example, a regular String variable cannot be assigned null:

var regularStr: String = "hello world" // default initialization produces non-null type
regularStr = null // compilation error

To allow null assignments, declare the variable with a nullable type by appending ? to the base type:

var optionalStr: String? = "greeting" // nullable string type
optionalStr = null // valid assignment
print(optionalStr)

You can safely access methods and properties on non-null references with zero NPE risk:

val strLength = regularStr.length

Accessing the same property on a nullable reference will trigger a compilation error, as the value may be null:

val strLength = optionalStr.length // error: variable `optionalStr` may be null

There are several approved approaches to access properties on nullable references safely.

Null Checks in Conditional Statements

You can explicitly check if a nullable value is null before accessing its members, and handle both cases separately:

val computedLength = if (optionalStr != null) optionalStr.length else -1

The compiler tracks the result of null checks, allowing safe access to the nullable value inside the positive branch. More complex conditional logic is also supported:

val testStr: String? = "Kotlin Development"
if (testStr != null && testStr.length > 10) {
    print("Valid string with length ${testStr.length}")
} else {
    print("Empty or null string")
}

Note that this smart cast behavior only works for immutable values: local variables that are not modified between the check and usage, or val members that are not overridable and have a backing field. This prevents cases where the value becomes null after the check is performed.

Safe Call Operator

The safe call operator ?. returns the result of the property/method access if the receiver is non-null, and returns null otherwise:

val nonNullText = "Programming"
val nullText: String? = null
println(nullText?.length) // outputs null
println(nonNullText?.length) // outputs 11, safe call is redundant here but valid

The resulting type of a safe call expression is always nullable, e.g. the above examples return Int?.

Safe calls are especially useful for chained access. For example, if a TeamMember may not be assigned to a project, and each project may or may not have a lead engineer, you can fetch the lead's full name (if it exists) as follows:

teamMember?.assignedProject?.leadEngineer?.fullName

If any receiver in the chain is null, the entire expression returns null immediately.

You can combine safe calls with the let scope function to run operations only on non-null values:

val mixedList: List<String?> = listOf("Android", null, "Kotlin", null)
for (entry in mixedList) {
    entry?.let { println(it) } // prints only non-null entries, skips nulls
}

Safe calls can also be used on the left side of assignment operations. If any receiver in the call chain is null, the assignment is skipped entirely, and the right-hand side expression is not evaluated:

// If `employee` or `employee.division` is null, the assignment is skipped
employee?.division?.lead = talentPool.fetchAvailableManager()

Elvis Operator

The Elvis operator ?: provides a concise alternative to if-else expressions for handling nullable values. It returns the left-hand side value if its non-null, otherwise returns the right-hand side value. The right-hand side is only evaluated if the left-hand side is null:

val lengthVal = optionalStr?.length ?: -1

Since throw and return are valid expressions in Kotlin, they can be used on the right-hand side of the Elvis operator for validation logic:

fun parseNode(node: TreeNode): String? {
    val parentNode = node.getParent() ?: return null
    val nodeLabel = node.getLabel() ?: throw IllegalArgumentException("Node must have a valid label")
    // remaining function logic
}

Non-Null Assertion Operator

The non-null assertion operator !! converts any nullable value to its non-null equivalent, and throws an NPE if the value is null. This is intended for cases where you are certain the value cannot be null, and accept the risk of an explicit NPE if your assumption is wrong:

val forcedLength = optionalStr!!.length // throws NPE if optionalStr is null

Safe Type Cast

Regular type casts throw a ClassCastException if the value is not compatible with the target type. The safe cast operator as? returns null instead of throwing an exception if the cast fails:

val convertedInt: Int? = inputValue as? Int

Filtering Null Values from Collections

If you have a collection with nullable element types, you can use the filterNotNull utility to remove all null entries and produce a collection of non-null elements:

val optionalIntList: List<Int?> = listOf(3, 7, null, 12, null, 19)
val pureIntList: List<Int> = optionalIntList.filterNotNull()