Type checking with is operator in Kotlin

Introduction

We use the is operator to check if a value is of a certain type. It helps us decide what to do based on the kind of data we have.

When you want to do different things depending on the type of a variable.

When you receive input that could be different types and need to handle each type safely.

When you want to avoid errors by making sure a variable is the right type before using it.

When you want to write clear and safe code that adapts to different data types.

Syntax

Kotlin

if (variable is Type) {
    // code to run if variable is of Type
}

The is operator checks if the variable is an instance of the specified type.

Inside the if block, Kotlin smart casts the variable to that type automatically.

Examples

Checks if obj is a String, then prints its length.

Kotlin

val obj: Any = "Hello"
if (obj is String) {
    println(obj.length)  // obj is treated as String here
}

Checks if number is an Int, then adds 10 and prints.

Kotlin

val number: Any = 42
if (number is Int) {
    println(number + 10)  // number is Int here
}

Function that prints different messages based on whether x is a Double.

Kotlin

fun checkType(x: Any) {
    if (x is Double) {
        println("Double value: $x")
    } else {
        println("Not a Double")
    }
}

Sample Program

This program goes through a list of different types. It uses the is operator to check each item's type and prints a message accordingly.

Kotlin

fun main() {
    val items: List<Any> = listOf("apple", 5, 3.14, true)
    for (item in items) {
        when {
            item is String -> println("String of length ${item.length}")
            item is Int -> println("Integer value: $item")
            item is Double -> println("Double value: $item")
            else -> println("Unknown type")
        }
    }
}

Important Notes

The is operator works like 'instanceof' in other languages but with smart casting.

You can use !is to check if a variable is NOT a certain type.

Smart casting only works if the variable is immutable (val) or not changed between checks.

Summary

Use the is operator to check a variable's type safely.

Inside the if block, Kotlin treats the variable as that type automatically.

This helps write clear and error-free code when working with different data types.

Practice

1. What does the is operator do in Kotlin?

easy

A. Checks if a variable is of a specific type

B. Changes the type of a variable

C. Creates a new variable

D. Deletes a variable

Solution

1. Step 1: Understand the purpose of is operator

   The is operator is used to check if a variable holds a value of a certain type.

2. Step 2: Differentiate from other options

   It does not change, create, or delete variables; it only checks type.

3. Final Answer:

   Checks if a variable is of a specific type -> Option A

4. Quick Check:

   Type check = A [OK]

Hint: Remember: is means 'is this type?' check [OK]

Common Mistakes:

• Thinking is changes the variable type
• Confusing is with variable creation
• Assuming is deletes variables

2. Which of the following is the correct syntax to check if obj is a String in Kotlin?

easy

A. if (obj instanceof String)

B. if (obj is String)

C. if (obj type String)

D. if (obj == String)

Solution

1. Step 1: Recall Kotlin syntax for type checking

   Kotlin uses is keyword to check types, not instanceof or other keywords.

2. Step 2: Match the correct syntax

   The correct syntax is if (obj is String).

3. Final Answer:

   if (obj is String) -> Option B

4. Quick Check:

   Correct syntax = C [OK]

Hint: Use is keyword, not Java's instanceof [OK]

Common Mistakes:

• Using Java syntax instanceof in Kotlin
• Writing obj type String which is invalid
• Comparing with == instead of type check

3. What will be the output of this Kotlin code?

fun checkType(x: Any) {
    if (x is Int) {
        println(x + 5)
    } else {
        println("Not an Int")
    }
}

checkType(10)
checkType("Hello")

medium

A. Error at runtime

B. 10
Not an Int

C. 15
Hello5

D. 15
Not an Int

Solution

1. Step 1: Analyze the first call checkType(10)

   10 is an Int, so inside the if block, x + 5 equals 15, printed as "15".

2. Step 2: Analyze the second call checkType("Hello")

   "Hello" is not an Int, so else block runs printing "Not an Int".

3. Final Answer:

   15 Not an Int -> Option D

4. Quick Check:

   Int check prints sum, else prints message = A [OK]

Hint: If is true, use variable as that type inside block [OK]

Common Mistakes:

• Assuming string "Hello" can be added to 5
• Expecting runtime error instead of else output
• Confusing output order

4. Identify the error in this Kotlin code snippet:

fun printLength(obj: Any) {
    if (obj is String) {
        println(obj.length())
    }
}

medium

A. No error, code is correct

B. Missing else block after if

C. Using parentheses with length property

D. Incorrect use of is operator

Solution

1. Step 1: Check usage of length on String

   In Kotlin, length is a property, not a function, so it should not have parentheses.

2. Step 2: Confirm other parts are correct

   The is operator is used correctly and else block is optional.

3. Final Answer:

   Using parentheses with length property -> Option C

4. Quick Check:

   Property access no parentheses = D [OK]

Hint: Remember: Kotlin properties have no parentheses [OK]

Common Mistakes:

• Adding parentheses to properties like length
• Thinking else block is mandatory
• Misusing is operator syntax

5. Given a list of Any elements, how can you create a new list containing only the strings using the is operator in Kotlin?

hard

A. val strings = list.filterIsInstance<String>()

B. val strings = list.filter { it is String }

C. val strings = list.map { if (it is String) it else null }

D. val strings = list.filter { it == String }

Solution

1. Step 1: Understand filtering by type

   To get only strings, Kotlin provides filterIsInstance<String>() which filters elements by type safely.

2. Step 2: Evaluate other options

   val strings = list.filter { it is String } filters by is String but keeps type as Any, not cast to String. val strings = list.map { if (it is String) it else null } maps to nullable list, not filtering. val strings = list.filter { it == String } compares with type itself, which is invalid.

3. Final Answer:

   val strings = list.filterIsInstance<String>() -> Option A

4. Quick Check:

   Use filterIsInstance for type filtering [OK]

Hint: Use filterIsInstance to get typed list quickly [OK]

Common Mistakes:

• Using filter without casting
• Mapping to nullable instead of filtering
• Comparing element to type object