Kotlin NullPointerException Fix

In this tutorial, you'll learn about Kotlin NullPointerException Fix. We cover key concepts, practical examples, and best practices.

The Problem

Your Kotlin app crashes with:

Exception in thread "main" kotlin.NullPointerException
    at com.example.MyClass.myMethod(MyClass.kt:10)

Kotlin is designed to eliminate null pointer exceptions through its type system (nullable Type? vs non-nullable Type). However, NPEs still occur when using the !! operator, calling Java code, accessing uninitialized lateinit properties, or using platform types with incorrect nullability assumptions.

Quick Fix

Step 1: Find the !! operator

Search your codebase for !!:

grep -rn "!!" --include="*.kt" src/

WRONG -- force unwrapping that can throw:

val name = nullableString!!

RIGHT -- use safe calls or let:

nullableString?.let { name ->
    println(name)
}

// Or with Elvis operator
val name = nullableString ?: "default"

Step 2: Fix lateinit property access

WRONG -- accessing lateinit before initialization:

class MyActivity {
    lateinit var user: User

    fun showUser() {
        println(user.name)  // NPE: lateinit property user has not been initialized
    }
}

RIGHT -- check if initialized:

class MyActivity {
    lateinit var user: User

    fun showUser() {
        if (::user.isInitialized) {
            println(user.name)
        } else {
            println("User not set yet")
        }
    }
}

Or use a nullable type instead:

class MyActivity {
    var user: User? = null

    fun showUser() {
        user?.let {
            println(it.name)
        }
    }
}

Step 3: Handle Java interop nullability

WRONG -- assuming a Java method never returns null:

val result = javaService.getData()  // platform type: String!
val length = result.length  // NPE if Java returns null

RIGHT -- treat platform types as nullable:

val result: String? = javaService.getData()  // explicitly nullable
val length = result?.length ?: 0

Annotate Java code with @Nullable and @NonNull:

import javax.annotation.Nullable;

public class JavaService {
    @Nullable
    public String getData() {
        return null;  // Kotlin now knows this can return null
    }
}

Step 4: Use the Elvis operator for safe defaults

WRONG -- no fallback for null:

fun getDisplayName(user: User?): String {
    return user.name  // compilation error or NPE
}

RIGHT -- chain with Elvis:

fun getDisplayName(user: User?): String {
    return user?.name ?: "Anonymous"
}

Step 5: Use requireNotNull and checkNotNull

For function parameters that must not be null:

fun process(name: String?) {
    val validName = requireNotNull(name) { "Name must not be null" }
    // validName is non-null from here
}

This throws IllegalArgumentException with a clear message instead of a generic NPE.

Step 6: Fix generic type nullability

WRONG -- non-nullable generic type with null values:

val list: List<String> = arrayListOf(null, "a", "b")  // compilation error

RIGHT -- use nullable type parameter:

val list: List<String?> = arrayListOf(null, "a", "b")

Use DodaTech's Kotlin Inspector to find !! usages, unsafe Java interop, and uninitialized lateinit properties across your codebase.

Prevention

• Avoid !! operator entirely -- use ?. and ?: instead.
• Use lateinit sparingly; prefer nullable types with ?.
• Annotate Java code with @Nullable/@NonNull for better Kotlin interop.
• Enable compiler warnings for platform type assignments.
• Use requireNotNull for defensive parameter validation.
• Treat all Java return values as nullable unless annotated otherwise.

Common Mistakes with null pointer

1. Using head and tail instead of pattern matching, causing runtime errors on empty lists
2. Forgetting that lazy evaluation defers computation until the value is forced, causing space leaks with unevaluated thunks
3. Using return to exit a function early instead of wrapping a pure value in the monad

These mistakes appear frequently in real-world KOTLIN code. DodaTech's contributors have identified these patterns through analysis of open-source projects and production systems.

Practice Exercise

Write a pure function that safely divides two integers using Maybe, then test it with edge cases like division by zero and negative numbers.

This exercise reinforces the concepts covered in this guide. Try implementing it before checking online solutions.

FAQ