Kotlin的when与Java的switch语句比较

1. Introduction

Kotlin and Java stand out as popular choices for building robust and scalable applications. Both languages offer unique features and syntax that contribute to their strengths.

In this tutorial, we’ll delve into Kotlin’s powerful when expression and Java’s traditional switch statement, comparing their usage, syntax, and capabilities. By examining code samples and providing detailed explanations, we aim to help understand the strengths and nuances of these constructs.

2. Java’s switch Statement

Java’s switch statement, while a longstanding feature of the language, has its limitations compared to Kotlin’s when expression. Before Java 7, the switch statement only supported primitives and enumerated types. As of Java 7, it also supports Strings. Let’s explore a simple example using Java’s switch statement:

int number = 3;
String description;
switch (number) {
    case 0:
        description = "Zero";
        break;
    case 1:
    case 2:
        description = "One or Two";
        break;
    case 3:
    case 4:
    case 5:
        description = "Between Three and Five";
        break;
    default:
        description = "Other";
}
System.out.println(description);

In this code, we initialize an integer variable number with the value three and use a switch statement to determine the content of the String variable description based on the value of number. The default case covers any other values, assigning “Other.” The final value of description is then printed to the console and in this specific instance will print “Between Three and Five”.

3. Kotlin’s when Expression

Kotlin introduces the versatile when expression, a more powerful and expressive alternative to Java’s switch statement. The when expression allows developers to replace a series of if-else statements with a concise and readable syntax. Let’s rewrite the first example as a when expression:

fun describeNumber(number: Int): String {
    return when (number) {
        0 -> "Zero"
        1, 2 -> "One or Two"
        in 3..5 -> "Between Three and Five"
        else -> "Other"
    }
}

The when expression in our describeNumber() function is handling the same comparisons and returning the same descriptions as the switch statement above. Notice how we can handle more complex comparisons at once while keeping the same logical meaning. That is to say, the when expression checks multiple values at once with comma-separated values to compare to, or can even check against ranges of numbers. Finally, if the number doesn’t match any of our expressions, our code executes the else block instead.

4. Comparing Java’s switch and Kotlin’s when

First, we’re going to take a look at the similarities between the switch statement used in Java and the when expression in Kotlin:

• switch statements in Java and when expressions in Kotlin are used for pattern matching. They usually allow us to compare the value of an expression against one or more possible values and execute different code blocks accordingly.
• Both constructs support multiple branches, allowing us to define different actions for different cases.

Finally, we’re going to highlight the differences between the switch statements in Java and when in Kotlin:

• Kotlin’s when is more flexible than Java’s switch when it comes to defining conditions. It allows for complex conditions, including ranges, type checks, and other expressions.
• In Kotlin’s when, we don’t need to use a break statement. The when expression doesn’t continue to the next expression by default.

5. Conclusion

In this article, we compared Kotlin’s powerful when expression with Java’s traditional switch statement.

Kotlin’s when expression offers a more versatile and expressive syntax, allowing developers to streamline their code and replace lengthy if-else structures with concise and readable constructs. On the other hand, Java’s switch statement, while a well-established feature, has limitations, such as supporting only primitive types, enumerated types, and the String type from Java 7 onwards.

Lastly, we looked at the similarities and differences between switch statements in Java and when expressions in Kotlin.

As always, the full implementation of these examples is available over on GitHub.