Control Flow

When replaces switch

Kotlin's when expression replaces Java's switch statement with a more powerful construct. It can match on values, types, ranges, and arbitrary predicates.

Basic Value Matching

val day = 3

val dayName = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    3 -> "Wednesday"
    4 -> "Thursday"
    5 -> "Friday"
    6 -> "Saturday"
    7 -> "Sunday"
    else -> "Invalid"
}
println(dayName)  // Wednesday

When used as an expression, it returns a value. The else branch is required when no branch matches.

Multiple Values and Ranges

Group values with commas. Check membership with in:

val score = 85

val grade = when (score) {
    in 90..100 -> "A"
    in 80 until 90 -> "B"
    in 70 until 80 -> "C"
    in 60 until 70 -> "D"
    else -> "F"
}

The in operator checks if a value falls within a range. until creates a half-open range (excludes the upper bound).

Type Checking

Use is to match on types. The compiler smart-casts the variable inside the branch:

fun describe(obj: Any): String {
    return when (obj) {
        is Int -> "Integer: $obj"
        is String -> "String of length ${obj.length}"
        is List<*> -> "List of ${obj.size} elements"
        else -> "Unknown type"
    }
}

The smart cast means obj is automatically treated as String inside the is String branch, so you can call .length without an explicit cast.

Without Argument

When used without an argument, each branch is a boolean condition. The first matching branch executes:

val temperature = 28

when {
    temperature >= 35 -> println("Extreme heat")
    temperature >= 25 -> println("Warm")
    temperature >= 15 -> println("Mild")
    else -> println("Cold")
}

This replaces chains of if-else-if with clearer syntax.

When as Statement

When can be used as a statement (no value returned) for side effects:

when (action) {
    "save" -> saveData()
    "delete" -> deleteData()
    "load" -> loadData()
    else -> println("Unknown action")
}

Ranges

Ranges in Kotlin are created with .. (inclusive) and until (exclusive). They implement the Iterable interface and work with for loops, in, and standard library functions:

// Inclusive range: 1, 2, 3, 4, 5
for (i in 1..5) {
    print("$i ")
}

// Exclusive range: 1, 2, 3, 4
for (i in 1 until 5) {
    print("$i ")
}

// Downward range: 5, 4, 3, 2, 1
for (i in 5 downTo 1) {
    print("$i ")
}

// Step: 1, 3, 5, 7, 9
for (i in 1..10 step 2) {
    print("$i ")
}

Iterating Collections

val fruits = listOf("apple", "banana", "cherry")

for (fruit in fruits) {
    println(fruit)
}

// With index
for ((index, fruit) in fruits.withIndex()) {
    println("$index: $fruit")
}

Destructuring in For Loops

Kotlin supports destructuring declarations in for loops. Any object with componentN() functions (including data classes and Map entries) can be destructured:

val capitals = mapOf(
    "USA" to "Washington",
    "Japan" to "Tokyo",
    "Germany" to "Berlin"
)

for ((country, city) in capitals) {
    println("$country -> $city")
}

// Data class destructuring
data class User(val name: String, val age: Int)
val users = listOf(User("Alice", 30), User("Bob", 25))

for ((name, age) in users) {
    println("$name is $age years old")
}

Break and Continue

Kotlin supports break and continue with labels for nested loops:

outer@ for (i in 1..5) {
    for (j in 1..5) {
        if (j == 3) continue@outer  // Skips to next i
        if (i == 4) break@outer     // Exits outer loop
        print("($i,$j) ")
    }
}
// Output: (1,1) (1,2) (2,1) (2,2) (3,1) (3,2)

Without labels, break and continue affect only the innermost loop.

If Returns a Value

In Kotlin, if is an expression, not a statement. It returns a value, so you can use it where other languages require ternary operators:

val max = if (a > b) a else b

// With blocks
val result = if (score >= 90) {
    println("Excellent!")
    "A"
} else if (score >= 80) {
    "B"
} else {
    "C"
}

The last expression in each branch is the return value. This eliminates the need for ternary operators (which Kotlin does not have).

If vs When

Use when for three or more branches or pattern matching. Use if-else for simple two-branch decisions:

// Simple: if-else is fine
val abs = if (x >= 0) x else -x

// Complex: when is clearer
val description = when {
    x > 0 -> "positive"
    x < 0 -> "negative"
    else -> "zero"
}

Elvis with If

The Elvis operator often replaces simple if-null checks:

// Verbose
val length = if (name != null) name.length else 0

// Concise
val length = name?.length ?: 0

The Elvis operator is preferred because it is more concise and signals null handling intent clearly.