Kotlin Double-Bang Operator (!!): Meaning, Null Safety, and Safer Alternatives

By the end of this page, you will understand what Kotlin's !! operator does, why it is related to Kotlin's null-safety system, and why it should usually be avoided when safer alternatives exist. You will also learn how to replace !! with patterns like safe calls, if checks, let, Elvis operators, and early returns in real Kotlin code.

Kotlin has null safety built into the language. That means Kotlin tries to prevent NullPointerException errors by distinguishing between:

• non-null types like String
• nullable types like String?

A nullable type may contain either a real value or null. Because of that, Kotlin does not let you call methods or access properties on a nullable value unless you handle the possibility of null.

The !! operator is called the not-null assertion operator.

When you write:

copyMap!!

you are telling Kotlin:

• "I am certain this value is not null."
• "Treat it as a non-null value right now."
• "If I am wrong, crash with a NullPointerException."

So this code:

copyMap!!.addMarker(...)

means:

1. Check copyMap
2. If it is not null, continue and call addMarker(...)

Think of a nullable variable as a box that might be empty.

• copyMap means "a box that may or may not contain a map"
• copyMap!! means "open the box and assume something is inside"

If the box contains the value, everything works. If the box is empty (null), your program crashes immediately.

So !! is like saying:

"Trust me, there is definitely something here."

That can be fine when you are truly certain. But if you are guessing, it is risky.

Core syntax

value!!

This converts a nullable value into a non-null value at runtime.

• If value is not null, it works
• If value is null, it throws NullPointerException

Example with !!

val name: String? = "Kotlin"
println(name!!.length)

This prints:

6

Because name is not null.

Example that crashes

val name: String? = null
println(name!!.length)

This throws a NullPointerException because name is null.

Your example

copyMap!!.addMarker(
    MarkerOptions()
        .position(london)
        .title()
)

Consider this code:

val city: String? = "London"
println(city!!.uppercase())

Step by step

1. city is declared as String?

   • This means it can hold either a String or null

2. city!! is evaluated

   • Kotlin checks the runtime value of city

3. Since city is actually "London", the check succeeds

   • Kotlin treats it as a non-null String

4. uppercase() is called

   • Result: LONDON

Now compare with this:

val city: String? = 
println(city!!.uppercase())

!! appears in real Kotlin code, but usually in limited situations.

Common places you may see it

• Android lifecycle code where a value is initialized before use, but Kotlin cannot prove it
• Interoperability with Java APIs that do not express nullability clearly
• Framework callbacks where a developer knows a value should exist at a specific moment
• Tests and prototypes where code is kept short and failure is acceptable

Example: Android map usage

override fun onMapReady(googleMap: GoogleMap) {
    copyMap = googleMap
}

fun addLondonMarker() {
    copyMap?.addMarker(
        MarkerOptions().position(london).title("Marker in London")
    )
}

Here, the safer approach is to only use the map after it has been initialized.

Example: reading optional configuration

val apiKey: String? = config["API_KEY"]
val keyLength = apiKey?.length ?: 0

This avoids !! and handles missing values safely.

Example: failing fast when null is a bug

In real projects, experienced Kotlin developers try to design code so !! is rare.

Common patterns used instead

Guard clauses

val map = copyMap ?: return
map.addMarker(MarkerOptions().position(london).title("Marker in London"))

This exits early if the value is missing.

Validation before work

fun showUserProfile(user: User?) {
    requireNotNull(user) { "user cannot be null" }
    println(user.name)
}

This is similar to !!, but gives a better error message.

Safe-call chains

val streetName = user?.address?.street?.name

This is very common in nested data structures.

Using non-null types where possible

class MapController(private val map: GoogleMap) {
    fun  {
        map.addMarker(MarkerOptions().position(london).title())
    }
}

1. Using !! just to silence compiler errors

Beginners often write !! because the compiler complains about nullability.

Broken approach

val name: String? = getName()
println(name!!.length)

This compiles, but may crash.

Better approach

val name: String? = getName()
println(name?.length ?: 0)

2. Assuming !! makes a value permanently non-null

!! only applies at that specific expression.

val text: String? = "Hi"
println(text!!.length)
// text is still declared as String?

The variable's type does not permanently change.

3. Using !! repeatedly

Hard-to-read code

user!!.address!!.street!!.name

This is fragile and likely to crash.

Better

Quick reference

What !! means

value!!

• Assert that value is not null
• If non-null, treat it as non-null
• If null, throw NullPointerException

Related null-safety operators

value?.method()      // safe call
value ?: fallback    // Elvis operator
value?.let { ... }   // run block if non-null

Common replacements for !!

val map = copyMap ?: return
map.addMarker(...)

copyMap?.addMarker(...)

requireNotNull(copyMap)
copyMap.addMarker(...)

When to avoid !!

• When the value may realistically be null
• When safer handling is easy
• When writing UI or lifecycle code with delayed initialization

When it may be acceptable

What does !! mean in Kotlin?

It is the not-null assertion operator. It tells Kotlin to treat a nullable value as non-null, and it throws NullPointerException if the value is actually null.

Is !! the same as Java null checking?

No. Java often allows null access until runtime. Kotlin normally forces you to handle nulls explicitly. !! bypasses that safety and behaves more like risky Java code.

Why does Android Studio insert !! sometimes?

During Java-to-Kotlin conversion, the tool may generate !! when it cannot safely infer whether a value should be nullable or non-null.

Should I use !! in Kotlin?

Usually only rarely. Prefer safer options like ?., ?:, let, or redesigning the code to use non-null types.

What exception does !! throw?

It throws a NullPointerException if the value is null.

Is !! ever okay in production code?

Yes, but sparingly. It can be acceptable when you are certain a value cannot be null at that point and other approaches would make the code less clear.

• Null safety — !! exists because Kotlin distinguishes nullable and non-null types.
• Nullable types — Understanding String? or GoogleMap? is necessary to understand !!.
• Safe call operator — ?. is the most common safer alternative.
• Elvis operator — ?: is useful for defaults and early returns.
• Smart casts — Kotlin can sometimes infer non-null values after checks.
• let scope function — Often used with nullable values after a safe call.
• lateinit properties — Another way to deal with delayed initialization in Kotlin.
• Java interoperability — Many !! cases appear when calling Java libraries from Kotlin.