What the Elvis Operator Does in Kotlin

By the end of this page, you will understand Kotlin's Elvis operator (?:), how it works with nullable values, and why it is equivalent to a simple if expression that checks for null. You will also see where it is commonly used in real Kotlin code and how to avoid common mistakes.

Kotlin has built-in null safety. One of the main ideas in Kotlin is that a variable can either be:

• non-nullable: it must always contain a value
• nullable: it may contain a value or null

The Elvis operator is written as ?:.

It means:

• use the value on the left if it is not null
• otherwise use the value on the right

So this code:

val list = mutableList ?: mutableListOf()

means:

• if mutableList is not null, assign it to list
• otherwise, create a new empty mutable list and assign that

This is equivalent to:

val list = if (mutableList != null) mutableList else mutableListOf()

The Elvis operator matters because handling null is extremely common in real programs. Data may be missing from:

• API responses

Think of the Elvis operator like a backup plan.

• First, try the value on the left.
• If that value exists, use it.
• If it is missing (null), fall back to the value on the right.

A simple analogy:

• nickname ?: "Guest"

This means:

• if the user has a nickname, use it
• otherwise, use "Guest"

So ?: is like saying: "Use this, otherwise use that."

The basic syntax is:

val result = nullableValue ?: fallbackValue

Example 1: Default string

val name: String? = null
val displayName = name ?: "Anonymous"
println(displayName)

Output:

Anonymous

Because name is null, Kotlin uses the value on the right side.

Example 2: Your list example

val mutableList: MutableList<String>? = null
val list = mutableList ?: mutableListOf()
println(list)

Output:

[]

If mutableList already had a value, that existing list would be used instead.

Example 3: Equivalent if expression

val mutableList: MutableList<String>? = 

 list =  (mutableList != ) {
    mutableList
}  {
    mutableListOf()
}

Consider this example:

val mutableList: MutableList<String>? = null
val list = mutableList ?: mutableListOf("A", "B")
println(list)

Step by step:

1. mutableList is declared as MutableList<String>?

   • The ? means it may be null.

2. mutableList is assigned null

   • So right now, it does not point to any list.

3. Kotlin evaluates this expression:

   mutableList ?: mutableListOf("A", "B")
   

4. Kotlin checks the left side: mutableList

   • Is it null?
   • Yes.

5. Because the left side is null, Kotlin evaluates and uses the right side:

The Elvis operator is used whenever a value might be missing and you want a default.

Common use cases

1. Default values for user input

val username = inputName ?: "Guest"

If the user did not provide a name, use a safe default.

2. Safe API data handling

val title = apiResponse.title ?: "Untitled"

API fields are often nullable.

3. Optional configuration values

val port = envPort ?: 8080

If no environment value exists, use a standard port.

4. Empty collections instead of null

val items = response.items ?: emptyList()

This avoids repeated null checks later.

5. Fallback object creation

val session = currentSession ?: createNewSession()

If there is no current session, create one.

6. UI display defaults

In real Kotlin projects, developers often use the Elvis operator in a few common patterns.

1. Guard clauses with early return

fun printName(name: String?) {
    val safeName = name ?: return
    println(safeName)
}

If name is null, the function returns immediately.

2. Throwing an error when a required value is missing

val token = config.token ?: throw IllegalStateException("Token is required")

This is very common when a value must exist.

3. Combining safe call and default

val itemCount = cart?.items?.size ?: 0

This safely navigates nested nullable values.

4. Replacing null collections with empty ones

val users = response.users ?: emptyList()

This makes later code simpler because you can iterate without checking for null.

5. Validation and fallback

1. Thinking ?: is a ternary operator

In some languages, ? : is a ternary conditional operator. Kotlin does not have that style of ternary operator.

For example, Java has:

condition ? value1 : value2

But Kotlin's ?: is specifically the Elvis operator, used for null fallback.

2. Using it on non-nullable values

Broken idea:

val name: String = "Sam"
val result = name ?: "Anonymous"

This is pointless because name can never be null.

Use Elvis when the left side is nullable:

val name: String? = null
val result = name ?: "Anonymous"

3. Forgetting that the right side is the fallback

Broken understanding:

val number: ? = 
 result = number ?: 

Elvis operator vs if expression

Both are equivalent for basic null checks.

Elvis operator vs safe call

Quick syntax

val result = nullableValue ?: fallbackValue

Meaning

• Use the left side if it is not null
• Otherwise use the right side

Equivalent form

val result = if (nullableValue != null) nullableValue else fallbackValue

Common patterns

val name = input ?: "Guest"
val length = text?.length ?: 0
val users = response.users ?: emptyList()
val token = config.token ?: throw IllegalStateException("Missing token")
val item = value ?: return

Rules to remember

• ?: is the Elvis operator
• It is used for null fallback
• It is not the same as a ternary operator from other languages
• It only checks for null, not empty strings or empty collections
• It works especially well with ?.

What does ?: mean in Kotlin?

It is the Elvis operator. It returns the value on the left if that value is not null; otherwise, it returns the value on the right.

Is Kotlin ?: the same as the ternary operator in Java?

No. Kotlin does not have Java's condition ? a : b ternary operator. Kotlin's ?: is specifically for handling null values.

Why is mutableList ?: mutableListOf() the same as an if check?

Because both expressions do the same null test:

• if mutableList is not null, use it
• otherwise, create a new mutable list

When should I use the Elvis operator in Kotlin?

Use it when a value might be null and you want to provide a default, return early, or throw an exception.

Can I use the Elvis operator with throw or return?

Yes. This is common in Kotlin:

 user = currentUser ?: 
 token = config.token ?:  IllegalStateException()

• Null safety — The Elvis operator is part of Kotlin's null-safety system.
• Nullable types — You need to understand String?, Int?, and other nullable types to use Elvis correctly.
• Safe call operator (?.) — Often combined with Elvis to safely access properties and then provide a default.
• if expressions — Kotlin's if can return values, which is why it can replace simple Elvis expressions.
• Not-null assertion (!!) — A related null-handling tool, but much less safe.
• Smart casts — Kotlin can treat values as non-null after null checks in some situations.
• Collections in Kotlin — Elvis is often used to replace nullable collections with emptyList() or mutableListOf().
• Guard clauses — Elvis is commonly used with return or throw for early exits.