Kotlin: Converting Nullable Values to Non-Nullable with Default Logic

Kotlin is a modern programming language that adds safety and conciseness to your code by handling nullable values with its type system. If you've worked with Java in the past, you are likely familiar with the infamous NullPointerException. Kotlin aims to reduce this risk by having nullability built into its type system.

In Kotlin, a type cannot hold a null value unless it is explicitly allowed. These "nullable" types are marked with a ?. However, real-world applications need to frequently interact with nullable data, like a variable that holds a possible null due to some data source or computation. For such scenarios, it's essential to convert nullable values to non-nullable ones, potentially with a default value or logic.

Handling Nullable Types in Kotlin

Let's begin by creating a simple example of a nullable data type and examine how we can handle it:

var name: String? = null

Here, the variable name can hold either a String or a null. Now, imagine you want to always provide a non-null name for user display, perhaps defaulting to "Guest" when the name is null.

Using the Elvis Operator

The Elvis operator ?: is a popular way to provide a default value. If the expression on the left is not null, it returns that; otherwise, it evaluates the right side:

val displayName: String = name ?: "Guest"

In the above example, displayName will have the value "Guest" if name is null. Otherwise, it holds the value of name.

Using let Function

Kotlin provides a let function that operates safely only when the variable is not null:

name?.let {
    println("Name: $it")
} ?: run {
    println("Name is not available, using 'Guest'.")
}

If name is not null, the let block executes. If null, the run block provides an alternative.

Using requireNotNull

If you're sure that a value should not be null at runtime and wish to enforce it, use requireNotNull, which throws an IllegalArgumentException for null values:

val notNullName: String = requireNotNull(name) { "Name must not be null" }

Though usually not recommended unless necessary, it helps assert non-nullability within your logic confidently.

Using the !! Operator

Another option in Kotlin is the not-null assertion operator !!:

val definitelyName: String = name!!

While neat, it could result in a NullPointerException if name is indeed null. Thus, use it when you're confident of a value being non-null or when desiring guaranteed system failures on nulls for testing.

Conclusion

Converting nullable types to non-nullable in Kotlin involves choosing strategies based on your use case. The Elvis operator is the quickest means, while let allows more control and logic. In volatile or sanity checking scenarios, requireNotNull or !! enforce constraints at runtime.

Understanding these tools empowers you to write safer and more robust Kotlin code while minimizing runtime exceptions caused by nulls in your application.