Skip to main content

Kotlin Null Safety Patterns

Null pointer exceptions have long been a significant source of frustration for developers, often referred to as the "billion-dollar mistake" by Tony Hoare, who introduced null references in 1965. Kotlin addresses this problem with a comprehensive system for null safety built into the language.

In this guide, we'll explore Kotlin's null safety features and patterns that help you write more robust code that's resistant to null pointer exceptions.

Understanding Nullable vs Non-nullable Types​

At the core of Kotlin's null safety is the type system that distinguishes between nullable and non-nullable types.

kotlin
// Non-nullable String - can't be null
val name: String = "John"

// Nullable String - can be null
val nickname: String? = null

By default, types in Kotlin are non-nullable, meaning they cannot hold null values. To make a type nullable, you add a question mark (?) after the type.

Safe Call Operator (?.)​

The safe call operator (?.) allows you to safely access properties or call methods on potentially null objects.

kotlin
// Example: Accessing properties safely
val name: String? = "John"
val nameLength: Int? = name?.length

// When the object is null
val nullName: String? = null
val nullNameLength: Int? = nullName?.length // Returns null instead of throwing NPE

println("Name length: $nameLength") // Output: Name length: 4
println("Null name length: $nullNameLength") // Output: Null name length: null

This operator is especially useful in chains:

kotlin
// Chain of safe calls
val customer: Customer? = getCustomerById("123")
val city: String? = customer?.address?.city

// Without safe calls, this would require multiple null checks:
/*
if (customer != null) {
    val address = customer.address
    if (address != null) {
        val city = address.city
        // Use city
    }
}
*/

Elvis Operator (?:)​

Named for its visual resemblance to Elvis Presley's hairstyle, this operator provides a default value when an expression is null.

kotlin
// Basic usage
val name: String? = null
val displayName = name ?: "Unknown"

println(displayName) // Output: Unknown

// Real-world example: user preferences
val userPreferredTheme: String? = getUserThemePreference()
val theme = userPreferredTheme ?: "light-mode"

You can also use the Elvis operator to handle errors or exit functions:

kotlin
fun getShippingAddress(customer: Customer?): Address {
    // Return early if customer is null
    val validCustomer = customer ?: return Address("Default Street")
    
    // Process validCustomer (which is now non-null)
    return validCustomer.shippingAddress ?: Address("Default Street")
}

Non-null Assertion Operator (!!)​

The non-null assertion (!!) converts a nullable type to a non-nullable type and throws a NullPointerException if the value is null. Use this operator with caution!

kotlin
val nullableName: String? = "John"
val definitelyNotNullName: String = nullableName!!
println(definitelyNotNullName) // Output: John

// This will throw NullPointerException
val nullName: String? = null
val willThrow: String = nullName!! // NPE: nullName is null

Best Practice: Avoid the !! operator whenever possible. It essentially defeats Kotlin's null safety system and should be used only when you're absolutely certain a value isn't null (and can't prove it to the compiler).

Smart Casts​

Kotlin's compiler is smart enough to track null checks and automatically cast variables when appropriate.

kotlin
fun processLength(text: String?) {
    // First, check if text is not null
    if (text != null) {
        // Inside this block, text is automatically cast to non-nullable String
        println("Text length is ${text.length}") // No need for safe call
    } else {
        println("Text is null")
    }
}

Nullability and Collections​

When working with collections, it's important to understand the difference between a nullable collection and a collection of nullable items:

kotlin
// A nullable list of non-nullable strings
val nullableList: List<String>? = null

// A non-nullable list of nullable strings
val listOfNullables: List<String?> = listOf("A", null, "B")

// Safely working with nullable lists
val count = nullableList?.size ?: 0
println("List has $count items") // Output: List has 0 items

// Processing lists with nullable items
listOfNullables.forEach { item ->
    val printableItem = item ?: "Unknown"
    println("Item: $printableItem")
}
// Output:
// Item: A
// Item: Unknown
// Item: B

Real-world Example: User Authentication​

Here's a practical example showing null safety in a user authentication system:

kotlin
data class User(val id: String, val name: String, val email: String?)

class AuthenticationService {
    private var currentUser: User? = null
    
    fun login(userId: String, password: String): Boolean {
        // Simulate authentication
        val user = getUserFromDatabase(userId, password)
        if (user != null) {
            currentUser = user
            return true
        }
        return false
    }
    
    fun getCurrentUserEmail(): String {
        // Combine safe call and Elvis operator for clean null handling
        return currentUser?.email ?: "[email protected]"
    }
    
    fun sendEmailNotification(message: String) {
        val user = currentUser ?: run {
            println("No user logged in, can't send notification")
            return
        }
        
        val emailAddress = user.email
        if (emailAddress == null) {
            println("User ${user.name} has no email address")
        } else {
            println("Sending '$message' to $emailAddress")
        }
    }
    
    // Simulate database access
    private fun getUserFromDatabase(userId: String, password: String): User? {
        // In a real app, this would check credentials against a database
        return if (userId == "admin" && password == "password") {
            User("1", "Admin", "[email protected]")
        } else {
            null
        }
    }
}

Usage example:

kotlin
fun main() {
    val auth = AuthenticationService()
    
    // Try to send notification before login
    auth.sendEmailNotification("Hello") // Output: No user logged in, can't send notification
    
    // Login and send notification
    if (auth.login("admin", "password")) {
        println("Login successful")
        auth.sendEmailNotification("Welcome back!")
        // Output: Sending 'Welcome back!' to [email protected]
    } else {
        println("Login failed")
    }
}

let() Function with Nullable Types​

The let() scope function is particularly useful for nullable types. It executes the given block only if the value is not null:

kotlin
val name: String? = "John"
val greeting: String = name?.let { 
    "Hello, $it!" 
} ?: "Hello, Guest!"

println(greeting) // Output: Hello, John!

val nullName: String? = null
val nullGreeting = nullName?.let { 
    "Hello, $it!" 
} ?: "Hello, Guest!"

println(nullGreeting) // Output: Hello, Guest!

Best Practices for Null Safety​

  1. Prefer Non-nullable Types: Design your APIs to use non-nullable types when possible.

  2. Minimize Use of !!: The non-null assertion operator bypasses null safety and should be avoided unless absolutely necessary.

  3. Use Early Returns with Elvis: Combine the Elvis operator with returns for clean early-exit patterns.

  4. Consider Platform Types Carefully: When interoperating with Java, be wary of platform types (types coming from Java that Kotlin doesn't know the nullability of).

  5. Use Late-initialized Properties: For properties that can't be initialized in the constructor but will definitely be initialized before use, consider lateinit:

kotlin
class MainViewModel {
    // No need for DataRepository? even though we can't initialize it here
    lateinit var repository: DataRepository
    
    fun initialize() {
        repository = DataRepository()
    }
    
    fun loadData() {
        // If repository hasn't been initialized, this would throw
        // UninitializedPropertyAccessException, not NullPointerException
        repository.fetchData()
    }
}
  1. Delegate Nullable Properties: For class properties that might be null but usually aren't, consider lazy initialization:
kotlin
val cachedUserData: UserData? by lazy {
    loadUserDataFromCache()
}

Summary​

Kotlin's null safety system provides a robust way to handle null values and prevent null pointer exceptions. By using nullable types, safe calls (?.), the Elvis operator (?:), and smart casts, you can write more reliable code that handles null cases gracefully.

Key takeaways:

  • Use the type system to distinguish between nullable (Type?) and non-nullable (Type) values
  • Access properties of nullable objects safely with the ?. operator
  • Provide default values using the Elvis operator (?:)
  • Rely on smart casts to avoid unnecessary null checks
  • Avoid the !! operator when possible
  • Use scope functions like let() for cleaner null handling

By embracing these null safety patterns, you'll write more robust Kotlin code that's less prone to runtime exceptions.

Additional Resources​

Exercises​

  1. Create a function to safely extract the first character of a nullable string and return it capitalized, or return "N/A" if the string is null or empty.

  2. Write a function that processes a list of nullable strings and returns a list containing only the non-null strings that have at least 3 characters.

  3. Refactor this Java-style code to use Kotlin null safety patterns:

    kotlin
    fun getUserCity(user: User?): String {
        if (user == null) {
            return "Unknown"
        }
        val address = user.getAddress()
        if (address == null) {
            return "Unknown"
        }
        val city = address.getCity()
        if (city == null) {
            return "Unknown"
        }
        return city
    }

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)