Kotlin Switch Case: Master the When Expression for Better Control Flow

What is Kotlin Switch Case?

Kotlin does not have a traditional switch case statement like Java or C++. Instead, kotlin’s when expression provides all switch case functionality plus additional features like pattern matching and smart casting. The when expression represents a more flexible and expressive way to handle conditional expression evaluation compared to conventional switch case statements found in other programming languages.

The when expression can evaluate multiple possible values and execute corresponding blocks of code based on which conditions match. Here’s a simple example showing basic when syntax with integer values:

fun main(args: Array<String>) { 
    val number = 3 
    val result = when (number) { 
        1 -> "One" 
        2 -> "Two" 
        3 -> "Three" 
        else -> "Unknown" 
    } 
    print(result) 
}
                    

This code demonstrates how the when expression evaluates the variable and returns a string value based on the match. The else branch serves as the default case when no other conditions are satisfied.

Basic When Expression Syntax and Examples

The fundamental when syntax follows the pattern: when(variable) { value -> action }. This structure allows developers to write clean, readable code that handles multiple cases efficiently. The when expression automatically breaks after matching a condition, eliminating the need for break statements that plague traditional java switch statement implementations.

Consider this practical example determining the day of week using integers 1-7:

fun main(args: Array<String>) { 
    val day = 4 
    when (day) { 
        1 -> print("Monday") 
        2 -> print("Tuesday") 
        3 -> print("Wednesday") 
        4 -> { 
            print("Thursday") 
            print(" - Midweek!") 
        } 
        5 -> print("Friday") 
        6, 7 -> print("Weekend") 
        else -> print("Invalid day") 
    } 
}
                    

This example shows both single-line statements and block statements using curly braces. The else branch works as the default case, ensuring the overall expression handles all possible input values. Unlike other languages requiring explicit break keywords, kotlin’s when expression prevents fall-through behavior automatically.

When Expression vs Java Switch Statement

Comparing kotlin when with the traditional java switch statement reveals significant advantages. Java’s switch requires break statements to prevent fall-through, creating verbose code prone to errors. Kotlin’s when expression eliminates this requirement while providing cleaner syntax.

Java Switch Statement:

int day = 2; 
String result; 
switch (day) { 
    case 1: 
        result = "Monday"; 
        break; 
    case 2: 
        result = "Tuesday"; 
        break; 
    default: 
        result = "Unknown"; 
        break; 
}
                    

Kotlin When Expression:

val day = 2 
val result = when (day) { 
    1 -> "Monday" 
    2 -> "Tuesday" 
    else -> "Unknown" 
}
                    

The difference becomes clear: kotlin’s approach requires fewer lines of code and eliminates potential break statement errors. The when expression can function as both an expression returning values and a statement performing actions. Memory efficiency improves because when evaluates all conditions at once rather than sequential if-else checking.

Advanced When Expression Features

Multiple Conditions and Ranges

When expressions support combining multiple values using commas and checking ranges with the “in” operator. This feature allows developers to group related conditions together efficiently:

val score = 85 
val grade = when (score) { 
    0, 1, 2, 3, 4 -> "F" 
    in 5..59 -> "D" 
    in 60..69 -> "C" 
    in 70..79 -> "B" 
    in 80..100 -> "A" 
    else -> "Invalid score" 
}
                    

Range checking works with string ranges and custom ranges as well. The “!in” operator excludes specific ranges from evaluation.

Type Checking and Smart Casting

The is operator enables type checking within when expressions, and kotlin automatically performs smart casting within matched branches:

fun processData(input: Any) { 
    when (input) { 
        is String -> print("String length: ${input.length}") 
        is Int -> print("Integer value: $input") 
        is List<*> -> print("List size: ${input.size}") 
        else -> print("Unknown type") 
    } 
}
                    

This example demonstrates how kotlin’s smart casting automatically converts the input variable to the appropriate type within each branch, eliminating manual casting requirements.

Boolean Expressions and Guards

When expressions can operate without subjects using boolean conditions, replacing complex if-else chains:

val temperature = 25 
val humidity = 80 

when { 
    temperature > 30 && humidity > 70 -> print("Hot and humid") 
    temperature < 10 -> print("Cold") 
    humidity > 90 -> print("Very humid") 
    else -> print("Pleasant weather") 
}
                    

When as Expression vs Statement

The distinction between using when as an expression versus a statement affects how you structure your code. When used as an expression, the when construct returns a value that can be assigned to a variable:

enum class UserRole { ADMIN, USER, GUEST } 

fun determineAccess(role: UserRole): String { 
    return when (role) { 
        UserRole.ADMIN -> "Full access" 
        UserRole.USER -> "Limited access" 
        UserRole.GUEST -> "Read-only access" 
    } 
}
                    

When expressions must be exhaustive, covering all possible cases or including an else branch. When statements don’t require exhaustive checking since they don’t return values.

Working with Enums and Sealed Classes

Enum classes work exceptionally well with when expressions. Consider this HTTP status code example:

enum class HttpStatus(val code: Int) { 
    SUCCESS(200), 
    NOT_FOUND(404), 
    SERVER_ERROR(500) 
} 

fun handleResponse(status: HttpStatus) { 
    when (status) { 
        HttpStatus.SUCCESS -> print("Request successful") 
        HttpStatus.NOT_FOUND -> print("Resource not found") 
        HttpStatus.SERVER_ERROR -> print("Internal server error") 
    } 
}
                    

Sealed classes provide even more powerful pattern matching capabilities:

sealed class NetworkState { 
    object Loading : NetworkState() 
    data class Success(val data: String) : NetworkState() 
    data class Error(val message: String) : NetworkState() 
} 

fun handleNetworkState(state: NetworkState) { 
    when (state) { 
        is NetworkState.Loading -> print("Loading...") 
        is NetworkState.Success -> print("Data: ${state.data}") 
        is NetworkState.Error -> print("Error: ${state.message}") 
    } 
}
                    

The kotlin compiler ensures exhaustive checking for sealed classes, preventing runtime errors from unhandled cases.

Best Practices for Kotlin When Expressions

Following these best practices ensures effective use of when expressions in your kotlin code:

• Always include an else branch for when expressions to handle unexpected values
• Group related conditions together using commas for better readability
• Use meaningful variable names in when subjects for self-documenting code
• Prefer when over long if-else chains when checking the same variable
• Keep when branches concise; extract complex logic to separate functions
• Use when with sealed classes and enum class types for type-safe state management

The kotlin compiler optimizes when expressions with constants into jump tables, improving performance over traditional conditional statements.

Common Mistakes and How to Avoid Them

Several common mistakes plague developers learning when expressions:

Wrong approach - forgetting else branch:

// This causes compilation error 
val result = when (value) { 
    1 -> "One" 
    2 -> "Two" 
}
                    

Correct approach:

val result = when (value) { 
    1 -> "One" 
    2 -> "Two" 
    else -> "Other" 
}
                    

Other mistakes include using mutable variables in when subjects, not leveraging smart casting after type checks, and creating overly complex when expressions that should be refactored into separate functions.

Performance Considerations

Kotlin’s compiler optimizes when expressions into efficient jump tables for constant values, providing better performance than sequential if-else chains. When working with enum class values and sealed classes, the compiler generates highly optimized bytecode.

Memory usage benefits emerge from when expressions’ efficient evaluation strategy. The program’s flow becomes more predictable, and the kotlin runtime can optimize execution paths more effectively than traditional switch case statements.