Kotlin : 100 Interview Questions and Answers PART14

66. The purpose of the “!!” operator in Kotlin

In Kotlin, the !! operator is called the "not-null assertion operator".

What It Does

It asserts that a nullable variable is not null — and throws a NullPointerException (NPE) if it is.

val name: String? = null
val length = name!!.length  // 🔥 Throws NullPointerException

It tells the compiler: “I know this is not null. Trust me.” 😬

Why You Should Be Careful

The !! operator bypasses Kotlin’s null-safety — one of the key features of the language.

Using it:

• - Makes code unsafe
• - Can lead to runtime crashes (just like in Java)

When to Use !!

• - Only when you're absolutely certain a value is not null
• - Usually in very low-level or quick debugging situations
• - Rare in clean, production-ready Kotlin code

67. The purpose of the “?.” operator in Kotlin

The ?. operator in Kotlin is called the safe call operator.
It is used to safely access a property or call a method on a nullable object—without throwing a NullPointerException.

Syntax

val result = nullableObject?.someMethodOrProperty

If nullableObject is:

• ✅ Not null → It accesses the property or method.
• ❌ Null → It returns null without executing the call.

Example

val name: String? = null
val length = name?.length
println(length)  // Output: null (no crash)

68. The purpose of the “?:” operator in Kotlin

The ?: operator in Kotlin is called the Elvis operator.

Syntax:

val result = nullableValue ?: defaultValue

If nullableValue is not null, it's returned; otherwise, defaultValue is used.

Example:

val name: String? = null
val displayName = name ?: "Guest"

println(displayName) // Output: Guest

If name were "John", it would output John.

Common Use Cases

Without Elvis:

val result: Int
if (x != null) {
    result = x
} else {
    result = 0
}

With Elvis:

val result = x ?: 0

Use with throw or return

val user = getUser() ?: throw IllegalStateException("User not found")

69. The purpose of the “let” operator in Kotlin

In Kotlin, the let operator is a scope function used to execute a block of code on a non-null object or to perform operations within a scoped context.

Syntax

object?.let { it ->
    // use 'it' here
}

Or with named parameter:

object?.let { value ->
    println(value)
}

Common Use Cases

1. Null Safety / Null Check

Run code only if the object is not null:

val name: String? = "Bind the Logic"

name?.let {
    println("Length: ${it.length}")
}

If name is null, block won't run.

2. Avoid Temporary Variable Pollution

You can perform transformations without assigning intermediate variables:

val result = "kotlin".let {
    it.uppercase()
}.reversed()

println(result) // => NILTOK

3. Chaining or Function Pipelines

val final = "  hello  "
    .trim()
    .let { it.uppercase() }
    .let { "Greeting: $it" }

println(final) // Greeting: HELLO

4. Scoped Resource Usage or Logging

val file = File("demo.txt")

file.let {
    println("File path: ${it.absolutePath}")
}

let is best when you want to:

70. The concept of value classes in Kotlin

Value classes in Kotlin are a feature designed to create lightweight wrappers around a single value without the performance overhead of traditional objects. They’re particularly useful when you want type safety but don’t need the full power of a regular class.

Basic Syntax

@JvmInline
value class Email(val value: String)

This creates a type-safe Email wrapper around a String.

Benefits

• 1. No runtime overhead: The compiler can inline the value at usage points, avoiding object allocation.
• 2. Type safety: Prevents mixing up values of the same underlying type (e.g., Email vs Username).
• 3. Cleaner APIs: Encapsulate logic around a value (validation, formatting) in one place.

Key Rules of Value Classes

• 1. Must wrap exactly one property.
• 2. Can’t have init blocks (use factory or validation methods instead).
• 3. Must be final and cannot have open, abstract, or inner modifiers.
• 4. Cannot inherit other classes or interfaces (except interfaces).