Null Safety

In Java, any object reference can be null, and calling a method on one crashes with a NullPointerException — the most common production bug on the JVM. Kotlin splits every type in two. String can never hold null. String? (with a question mark) can hold a string or null. The compiler then refuses to let you call .length on a String? until you have dealt with the null case. The crash moves from runtime, in front of a user, to compile time, in front of you.

fun main() {
    val name: String = "Asha"        // never null
    var nickname: String? = null      // may be null

    println(name.length)
    println(nickname)

    nickname = "Ash"
    if (nickname != null) {
        println(nickname.length)      // allowed: checked just above
    }

    val middle: String? = null
    println("middle is null? ${middle == null}")
}

4
null
3
middle is null? true

fun main() {
    val name: String = null
    println(name)
}

Main.kt:2:24: error: null cannot be a value of a non-null type 'String'.

fun main() {
    val name: String? = null
    println(name)
}

fun main() {
    val name: String? = null
    println(name.length)
}

Main.kt:3:17: error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'.

fun main() {
    val name: String? = null
    println(name?.length ?: 0)
}

The safe call a?.b evaluates to a.b when a is not null, and to null otherwise — without calling anything. Safe calls chain: user?.address?.city is null if any link is null. The Elvis operator a ?: b gives a if it is not null, otherwise b. Because return and throw are expressions in Kotlin, the right side can also leave the function: val id = input ?: return.

class Address(val city: String?)
class User(val name: String, val address: Address?)

fun cityOf(user: User?): String = user?.address?.city ?: "unknown"

fun greetingLength(name: String?): Int {
    val n = name ?: return -1          // leave early when null
    return n.length                    // n is a plain String here
}

fun main() {
    val full = User("Asha", Address("Pune"))
    val noCity = User("Ravi", Address(null))
    val noAddress = User("Meera", null)

    println(cityOf(full))
    println(cityOf(noCity))
    println(cityOf(noAddress))
    println(cityOf(null))

    println(full.address?.city?.uppercase())
    println(noAddress.address?.city?.uppercase())

    println(greetingLength("hello"))
    println(greetingLength(null))
}

Pune
unknown
unknown
unknown
PUNE
null
5
-1

After you check x != null or x is String, the compiler remembers the check and treats x as the narrower type in the code that follows — a smart cast. It works for local vals and vars nothing else can change, and for val properties in the same module. For an explicit cast, as throws ClassCastException when the value is the wrong type, while the safe cast as? returns null instead — which pairs naturally with ?:.

fun describe(value: Any?): String {
    if (value == null) return "nothing"
    // value is now Any (non-null)
    if (value is String) return "string of ${value.length}"   // smart cast to String
    if (value !is Int) return "some ${value::class.simpleName}"
    return "int doubled ${value * 2}"                          // smart cast to Int
}

fun main() {
    println(describe(null))
    println(describe("hey"))
    println(describe(21))
    println(describe(2.5))

    val raw: Any = "not a number"
    val n: Int? = raw as? Int
    println(n)
    println((raw as? String)?.uppercase())
    println((raw as? Int) ?: 0)
}

nothing
string of 3
int doubled 42
some Double
null
NOT A NUMBER
0

class User {
    var nickname: String? = "ash"
}

fun main() {
    val user = User()
    if (user.nickname != null) {
        println(user.nickname.length)
    }
}

Main.kt:8:17: error: smart cast to 'String' is impossible, because 'nickname' is a mutable property that could be mutated concurrently.

class User {
    var nickname: String? = "ash"
}

fun main() {
    val user = User()
    val nick = user.nickname
    if (nick != null) {
        println(nick.length)
    }
}

fun main() {
    val value: Any = "42"
    val n = value as Int
    println(n + 1)
}

Exception in thread "main" java.lang.ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer (java.lang.String and java.lang.Integer are in module java.base of loader 'bootstrap')
	at MainKt.main(Main.kt:3)
	at MainKt.main(Main.kt)

fun main() {
    val value: Any = "42"
    val n = (value as? String)?.toIntOrNull() ?: 0
    println(n + 1)
}

x?.let { … } runs the block only when x is not null, with the non-null value as it. It is the idiomatic way to act on a nullable property (it reads the value once, so the smart-cast problem above cannot happen) and to transform a nullable value in a chain. takeIf { condition } goes the other way: it turns a value into null when the condition fails, so a validation step can feed into ?:. The standard library has nullable-aware helpers too: isNullOrEmpty(), isNullOrBlank(), orEmpty().

fun sendEmail(to: String) = println("sending to $to")

fun main() {
    val emails: List<String?> = listOf("[email protected]", null, "  ", "[email protected]")

    for (email in emails) {
        email?.let { sendEmail(it) }                 // skips null
    }

    val clean = emails.map { it?.trim()?.takeIf { t -> t.contains("@") } }
    println(clean)

    val first: String? = null
    println(first.isNullOrBlank())
    println(first.orEmpty().length)

    val port = "80a".toIntOrNull()?.takeIf { it in 1..65535 } ?: 8080
    println(port)
}

sending to [email protected]
sending to   
sending to [email protected]
[[email protected], null, null, [email protected]]
true
0
8080

Sometimes a property cannot get its value in the constructor — a test sets it in a setup method, a framework injects it, an Android view is bound in onCreate. Making it nullable would force ?. everywhere. lateinit var says "non-null, but assigned later"; reading it before assignment throws a clear exception, and ::prop.isInitialized checks first. It only works for var properties of non-primitive, non-null types. val x by lazy { … } is for the other case: a read-only value that is expensive to compute, calculated on first access and cached after that.

class Report {
    lateinit var title: String

    val summary: String by lazy {
        println("(computing summary once)")
        "Report: $title"
    }

    fun ready() = ::title.isInitialized
}

fun main() {
    val r = Report()
    println("ready? ${r.ready()}")
    r.title = "Q3 sales"
    println("ready? ${r.ready()}")

    println(r.summary)
    println(r.summary)   // cached, block does not run again
}

ready? false
ready? true
(computing summary once)
Report: Q3 sales
Report: Q3 sales

class Screen {
    lateinit var title: String

    fun show() = println(title.uppercase())
}

fun main() {
    Screen().show()
}

Exception in thread "main" kotlin.UninitializedPropertyAccessException: lateinit property title has not been initialized
	at Screen.getTitle(Main.kt:2)
	at Screen.show(Main.kt:4)
	at MainKt.main(Main.kt:8)
	at MainKt.main(Main.kt)

class Screen {
    lateinit var title: String

    fun show() = println(title.uppercase())
}

fun main() {
    val s = Screen()
    s.title = "home"
    s.show()
}

Java has no ? in its types, so when Kotlin calls a Java method it cannot know whether the result may be null. It gives the result a platform type, shown in IDE hints as String!: you may treat it as String or String?, and the compiler takes your word for it. Declare it String? and you are safe. Declare it String and Kotlin inserts a runtime check that fails immediately if Java hands back null — better than failing ten calls later, but still a crash.

fun main() {
    // System.getProperty is a Java method: its result is a platform type
    val home: String? = System.getProperty("app.home")   // not set in this run
    println(home ?: "app.home is not set")

    val javaMap = java.util.HashMap<String, Int>()
    javaMap["apples"] = 3
    val pears: Int? = javaMap["pears"]                  // Java returns null for a missing key
    println(pears)
    println(javaMap.getOrDefault("pears", 0))
}

app.home is not set
null
0

fun main() {
    val home: String = System.getProperty("app.home")
    println(home.length)
}

Exception in thread "main" java.lang.NullPointerException: getProperty(...) must not be null
	at MainKt.main(Main.kt:2)
	at MainKt.main(Main.kt)

fun main() {
    val home: String = System.getProperty("app.home") ?: "/opt/app"
    println(home.length)
}

fun main() {
    val email: String? = null
    println(email!!.length)
}

Exception in thread "main" java.lang.NullPointerException
	at MainKt.main(Main.kt:3)
	at MainKt.main(Main.kt)

fun main() {
    val email: String? = null
    println(email?.length ?: 0)
}

One more source surprises people: initialization order. A superclass constructor runs before the subclass's properties are assigned. If it calls an open function that the subclass overrides, that override sees its own non-null properties still holding null.

open class Base {
    init {
        println("Base init sees: ${describe()}")
    }
    open fun describe() = "base"
}

class Child : Base() {
    val name: String = "child"          // declared non-null
    override fun describe() = "name=$name"
}

fun main() {
    val c = Child()
    println("After construction: ${c.describe()}")
}

Base init sees: name=null
After construction: name=child

• !! on a null value.
• Java interop: a platform type assigned to a non-null type, or a Java method that receives null and dereferences it.
• lateinit read before assignment (a clearer exception, same idea).
• Initialization order: an open member called from a superclass constructor, or an init block that reads a property declared below it.
• An explicit throw NullPointerException() — in your code or a library.

The question mark can go in two places, and they mean different things. List<String?> is a list that always exists but may contain nulls. List<String>? is a list of real strings that may itself be missing. Many collection functions return nullable results because the answer may not exist: firstOrNull(), getOrNull(i), maxOrNull(), and map[key] for a key that is not present. filterNotNull() removes the nulls and changes the type to List<String>; mapNotNull { } maps and drops nulls in one pass.

fun main() {
    val raw: List<String?> = listOf("12", null, "7", "x", null, "30")

    val present: List<String> = raw.filterNotNull()
    println(present)

    val numbers: List<Int> = raw.mapNotNull { it?.toIntOrNull() }
    println(numbers)
    println(numbers.sum())

    println(numbers.firstOrNull { it > 100 })
    println(numbers.getOrNull(10))
    println(emptyList<Int>().maxOrNull())

    val prices = mapOf("tea" to 20, "coffee" to 35)
    val juice: Int? = prices["juice"]
    println(juice ?: "not on the menu")
    println(prices.getOrElse("juice") { 0 })

    val maybeList: List<String>? = null
    println(maybeList?.size ?: 0)
    println(maybeList.orEmpty().size)
}

[12, 7, x, 30]
[12, 7, 30]
49
null
null
null
not on the menu
0
0
0

Nullable type

A type with ?, such as String?, that can hold a value or null.

Safe call ?.

a?.b evaluates to null instead of calling b when a is null.

Elvis operator ?:

a ?: b gives a if it is not null, otherwise b. The right side can be return or throw.

Not-null assertion !!

Converts a nullable value to non-null, throwing NullPointerException if it is null.

Smart cast

The compiler treating a value as a narrower type after a null check or is check.

Safe cast as?

A cast that returns null instead of throwing ClassCastException.

lateinit

Marks a non-null var that is assigned after construction; reading it early throws UninitializedPropertyAccessException.

lazy

A delegate that computes a val on first access and caches the result.

Platform type

The type of a value coming from Java (shown as String!), whose nullability Kotlin cannot know.

filterNotNull()

Returns the non-null elements of a collection, typed as non-null.