Kotlin Programming Practice Exam

Question 1 Kotlin Programming

How do you sort by multiple criteria in Kotlin?

takeIf returns the object if the predicate is true, otherwise null:
val even = number.takeIf { it % 2 == 0 }
takeUnless does the opposite — returns the object if the predicate is false:
val odd = number.takeUnless { it % 2 == 0 } Chain sortedWith with compareBy + thenBy / thenDescending:
list.sortedWith(compareBy<User> { it.lastName }.thenBy { it.firstName })
This sorts first by last name, then by first name as a tiebreaker. withContext(Dispatchers.IO) { ... } switches the coroutine to a different dispatcher for the block, then returns to the original context. It is the idiomatic way to move work off the main thread:
val data = withContext(Dispatchers.IO) { api.fetch() } Ranges are created with .. or until:
for (i in 1..5) // 1,2,3,4,5
for (i in 1 until 5) // 1,2,3,4
for (i in 5 downTo 1 step 2) // 5,3,1
Ranges also support in checks: if (x in 1..10).

Question 2 Kotlin Programming

What is the result of a when expression with no matching branch and no else?

If when is used as an expression (its result is assigned), the compiler requires an else branch. Without it, the code does not compile. As a statement, unmatched values are simply ignored. throw has return type Nothing. Because Nothing is a subtype of every other type, you can throw in an Elvis branch:
val name = input ?: throw IllegalArgumentException("name required") Use the == or != operator with null:
if (name != null) { println(name.length) }
After this check, the compiler performs a smart cast so you can use name as a non-null type inside the block.

open: can be inherited; not abstract, can be instantiated
abstract: cannot be instantiated; may have abstract and concrete members
sealed: like abstract but restricts subclasses to the same file/package

By default, Kotlin classes are final.

Question 3 Kotlin Programming

What is the difference between forEach and forEachIndexed?

Coroutines are a lightweight concurrency framework. They allow writing asynchronous code sequentially without blocking threads:
launch { delay(1000); println("World") }
They are managed by a coroutine dispatcher and are much cheaper than threads. A data class automatically generates equals(), hashCode(), toString(), copy(), and componentN() functions:
data class User(val name: String, val age: Int)
It is designed to hold immutable data.

forEach { item -> ... }: iterates values.
forEachIndexed { i, item -> ... }: also exposes the 0-based index.

Prefer a normal for loop when you need break, continue, or return. Use JetBrains' @NotNull annotation (or JSR-305 @Nonnull / AndroidX @NonNull) on the Java declaration. Kotlin then sees the type as non-nullable and rejects null assignments at compile time.

Question 4 Kotlin Programming

What is a CoroutineScope in Kotlin?

A CoroutineScope defines the lifecycle of coroutines. When the scope is cancelled, all its coroutines are cancelled:
val scope = CoroutineScope(Dispatchers.IO)
Common scopes: GlobalScope, viewModelScope, lifecycleScope. crossinline prevents a lambda from doing non-local returns (i.e. return from the enclosing function). It is required when the lambda is invoked from a different context:
inline fun runBlock(crossinline block: () -> Unit) { object : Thread() { override fun run() = block() }.start() }

forEach { item -> ... }: iterates values.
forEachIndexed { i, item -> ... }: also exposes the 0-based index.

Prefer a normal for loop when you need break, continue, or return. Kotlin auto-generates get() and set() for properties. You can override them:
val name: String get() = "$first $last"
var password: String set(value) { if (value.length >= 8) field = value }
Inside a setter, the backing field is accessed via field.

Question 5 Kotlin Programming

What is destructuring in Kotlin?

run executes a block where this refers to the object. It returns the lambda result:

val result = service.run {
  port = 8080
  connect()
}

Useful for object configuration and computing a result. Destructuring lets you unpack an object into multiple variables in a single declaration:
val (name, age) = User("Alice", 30)
It relies on componentN() operator functions. Data classes provide these automatically. A MatchResult? — the first match or null:
val match = Regex("""(\w+)@(\w+)""").find(email)
Access groups via match.groupValues[1] or destructuring: val (user, domain) = match.destructured. Yes. A companion object can implement interfaces:

class MyClass {
  companion object : Factory<MyClass> {
    override fun create(): MyClass = MyClass()
  }
}

This is a powerful pattern for factory methods.

Question 6 Kotlin Programming

How does the !! operator interact with generic types?

flatMap maps each element to an Iterable and concatenates the results into a single flat list:
listOf("ab", "cd").flatMap { it.toList() } → [a, b, c, d]
Equivalent to map followed by flatten.

forEach { item -> ... }: iterates values.
forEachIndexed { i, item -> ... }: also exposes the 0-based index.

Prefer a normal for loop when you need break, continue, or return.

first: returns the first element or throws NoSuchElementException.
firstOrNull: returns the first element or null if the collection is empty (or no element matches the predicate).

Prefer firstOrNull when emptiness is possible. !! forces a non-null type that the smart cast system trusts throughout its scope. The thrown exception is KotlinNullPointerException (not NullPointerException), and the stack trace points to the !! site.

Question 7 Kotlin Programming

What does the getOrThrow function on Result do?

It returns the success value or rethrows the captured exception:
val data = runCatching { api.fetch() }.getOrThrow()
Useful when you want a Result-style chain to end in a thrown exception. buildString { ... } is an inline function that creates a StringBuilder, runs the lambda with it as this, and returns toString(). StringBuilder is the underlying type — use it directly only when reusing instances for performance. @SerialName("user_id") on a property or class overrides the name used by Kotlinx Serialization, decoupling Kotlin identifiers from the on-wire JSON / protobuf / CBOR field names. Call .toSet() or .toHashSet():
listOf(1, 2, 2, 3).toSet() → [1, 2, 3]
Use toMutableSet() if you need a mutable set. toHashSet() skips wrapper allocation by using the specific implementation.

Question 8 Kotlin Programming

How do you declare a nullable type in Kotlin?

Append a ? to the type declaration:
var name: String? = null
Without the ?, the compiler will reject any attempt to assign null. Unit is Kotlin's equivalent of void. It is a real type with a single value (Unit itself) and can be used as a return type or generic parameter. If a function returns Unit, you may omit the type declaration. val or var declared at file level. They act like global constants or variables but can be private, internal, or const val. Accessed as MyFile.PROPERTY from Java. A backing field is generated only if you use the default accessor or use field inside a custom accessor. A computed property with no field reference is just a function with property syntax.

Question 9 Kotlin Programming

What is the @JvmOverloads annotation used for?

open: can be inherited; not abstract, can be instantiated
abstract: cannot be instantiated; may have abstract and concrete members
sealed: like abstract but restricts subclasses to the same file/package

By default, Kotlin classes are final. @JvmOverloads generates Java-style overloads for default parameters:
fun foo(a: Int, b: Int = 0, c: Int = 0) becomes three Java methods: foo(int), foo(int, int), foo(int, int, int). Use the overload that takes both:
map.remove(key, value)
Returns true if the entry was removed. Useful for atomic compare-and-delete semantics. val or var declared at file level. They act like global constants or variables but can be private, internal, or const val. Accessed as MyFile.PROPERTY from Java.

Question 10 Kotlin Programming

What are Kotlin property accessors and how are they customized?

Kotlin auto-generates get() and set() for properties. You can override them:
val name: String get() = "$first $last"
var password: String set(value) { if (value.length >= 8) field = value }
Inside a setter, the backing field is accessed via field.

map[key] returns null when missing.
map.getValue(key) throws NoSuchElementException when missing.
map.getOrDefault(key, default) returns the supplied default.

copy() creates a new instance with the same values, allowing you to override specific properties:
val user2 = user1.copy(age = 25)
This is useful for working with immutable data objects.

Object expression: an anonymous class created on the fly: val o = object : Foo() { override fun bar() = 1 }
Object declaration: a named singleton: object Logger { fun log(m: String) = ... }

Object expressions are eager but local; declarations are lazy and global.

Question 11 Kotlin Programming

What is the purpose of Dispatchers.withName?

"a,b,c,d".split(",", limit = 2) → ["a", "b,c,d"]
The limit parameter caps the number of parts returned; remaining delimiters are kept in the last element. Without limit, the default is 0 (no cap).

const val: compile-time inlined into call sites, only primitives/Strings, only at top level or in objects.
val: read-only reference, evaluated at runtime, may have any type or custom getter, can be inside any class.

singleOrNull returns the only element of a collection, or null if there are zero or more than one. Useful for asserting uniqueness: users.singleOrNull { it.id == targetId }. Dispatchers.IO and Dispatchers.Default are configured with withName for debugging. The name appears in coroutine stack traces and thread dumps, making it easier to see where work is happening.

Question 12 Kotlin Programming

How do you build a String efficiently in Kotlin?

zip pairs elements from two collections of equal length into a List<Pair<A,B>>:
listOf("a","b").zip(listOf(1,2)) → [(a,1), (b,2)]
Stops at the shorter collection. zipWithNext pairs adjacent elements within a single collection. !! forces a non-null type that the smart cast system trusts throughout its scope. The thrown exception is KotlinNullPointerException (not NullPointerException), and the stack trace points to the !! site. Both accept a nullable receiver via safe call, but let returns the lambda result while also returns the original object. Use also for side effects that keep the object flowing through a chain. Use a StringBuilder or a buildString { append(...) } block:
val s = buildString { repeat(100) { append("x") } }
Avoid + concatenation in tight loops — each + allocates a new String.

Question 13 Kotlin Programming

What is the difference between step and downTo?

Kotlin provides rich functional operations:
val nums = listOf(1, 2, 3, 4, 5)

nums.filter { it > 2 } → [3, 4, 5]
nums.map { it * 2 } → [2, 4, 6, 8, 10]
nums.reduce { acc, i -> acc + i } → 15
nums.groupBy { it % 2 }

it returns the lambda result (the last expression) when the receiver is non-null; if the receiver is null, the whole let call returns null without executing the block.

step n controls the increment of any range.
downTo reverses the direction (descending range).

They can combine: for (i in 10 downTo 0 step 2) → 10, 8, 6, 4, 2, 0. Builds a single string from a collection with a separator, prefix, suffix, and optional transforms:
listOf(1,2,3).joinToString(prefix = "<", postfix = ">", separator = ", ") // "<1, 2, 3>"
Useful for logs, debug output, and quick formatting.

Question 14 Kotlin Programming

What is the when expression in Kotlin?

when replaces Java's switch and is more powerful:

when (x) {
  1 -> "one"
  2, 3 -> "two or three"
  in 4..10 -> "between 4 and 10"
  is String -> "it's a string"
  else -> "unknown"
}

It can be used as a statement or expression. Object initialization and configuration:

val dialog = AlertDialog.Builder(ctx).apply {
  setTitle("Hi")
  setMessage("World")
}.create()

Because it returns the receiver, it composes well in builder chains. Structured concurrency ensures that coroutines are scoped to a parent. If the parent is cancelled or fails, all child coroutines are automatically cancelled. This prevents coroutine leaks and simplifies error handling. crossinline prevents a lambda from doing non-local returns (i.e. return from the enclosing function). It is required when the lambda is invoked from a different context:
inline fun runBlock(crossinline block: () -> Unit) { object : Thread() { override fun run() = block() }.start() }

Question 15 Kotlin Programming

How does operator overloading for comparison work?

Override compareTo:
operator fun compareTo(other: Version) = this.major.compareTo(other.major)
Then <, <=, >, >=, and sort/sorted use it automatically.

Cold (flow { ... }): the producer runs only when a collector subscribes; each collector gets its own stream.
Hot (StateFlow, SharedFlow, Channel): emits whether or not anyone is collecting; multiple subscribers share or compete for values.

apply / also return the receiver (use to build and pass on the object).
let / run return the lambda result (use when you want to compute something new).

Choose based on what the chain needs to produce. Delegated properties use by to delegate get/set logic:
val name: String by lazy { computeName() }
Built-in delegates include lazy, observable, and vetoable. You can create custom delegates by implementing getValue()/setValue().

Question 16 Kotlin Programming

What is the crossinline keyword used for?

A lambda is an anonymous function written as a literal:
val square: (Int) -> Int = { x -> x * x }
If there is only one parameter, you can use it:
val square: (Int) -> Int = { it * it } crossinline prevents a lambda from doing non-local returns (i.e. return from the enclosing function). It is required when the lambda is invoked from a different context:
inline fun runBlock(crossinline block: () -> Unit) { object : Thread() { override fun run() = block() }.start() } Coroutines are a lightweight concurrency framework. They allow writing asynchronous code sequentially without blocking threads:
launch { delay(1000); println("World") }
They are managed by a coroutine dispatcher and are much cheaper than threads. Delegated properties use by to delegate get/set logic:
val name: String by lazy { computeName() }
Built-in delegates include lazy, observable, and vetoable. You can create custom delegates by implementing getValue()/setValue().

Question 17 Kotlin Programming

What are Kotlin ranges and how are they used?

Kotlin's basic types:

Numbers: Int, Long, Short, Byte, Float, Double
Boolean: true / false
Char: single character 'A'
String: text "Hello"

All types are objects — no primitives at the language level. Triple-quoted strings still support $variable and ${expr}:
val s = """Hello $name, you owe $$amount"""
To write a literal $ in a raw string, escape it: \$. Ranges are created with .. or until:
for (i in 1..5) // 1,2,3,4,5
for (i in 1 until 5) // 1,2,3,4
for (i in 5 downTo 1 step 2) // 5,3,1
Ranges also support in checks: if (x in 1..10). Use step on a range:
for (i in 0..20 step 5) println(i) // 0, 5, 10, 15, 20
For a decreasing range, use downTo: for (i in 20 downTo 0 step 5).

Question 18 Kotlin Programming

What is the difference between launch and async in coroutines?

Extension functions let you add new functions to existing classes without modifying their source code:
fun String.addExclamation(): String = this + "!"
Called as: "Hello".addExclamation() returns "Hello!".

List<T>: read-only interface — no add, remove, or clear methods.
MutableList<T>: extends List with mutation methods.

At runtime, listOf(...) may return an ArrayList — but you cannot call mutating methods through the List reference. Kotlin auto-generates get() and set() for properties. You can override them:
val name: String get() = "$first $last"
var password: String set(value) { if (value.length >= 8) field = value }
Inside a setter, the backing field is accessed via field.

launch: starts a coroutine that returns a Job (no result value). Fire-and-forget.
async: starts a coroutine that returns a Deferred<T>. Call .await() to get the result.

Use async when you need a return value.

Question 19 Kotlin Programming

What is the difference between sorted and sortedDescending?

String is a concrete, immutable sequence of Char. CharSequence is the interface implemented by String, StringBuilder, and StringBuffer. Library functions that only need to read chars should accept CharSequence for flexibility. Kotlin has no checked exceptions. You can throw and catch any exception without declaring it. The compiler will not force callers of a function to catch or rethrow IOException, SQLException, etc.

sorted returns a list in ascending order (natural ordering, requires Comparable).
sortedDescending returns the same elements in descending order.

Both allocate a new list; the original is unchanged.

reduce: combines elements starting with the first one; throws if the collection is empty.
fold: like reduce but takes an explicit initial accumulator; safe for empty collections.

listOf(1,2,3).reduce { a, b -> a + b } → 6
listOf<Int>().fold(0) { a, b -> a + b } → 0

Question 20 Kotlin Programming

What is the difference between buildString and StringBuilder?

apply / also return the receiver (use to build and pass on the object).
let / run return the lambda result (use when you want to compute something new).

Choose based on what the chain needs to produce. @SerialName("user_id") on a property or class overrides the name used by Kotlinx Serialization, decoupling Kotlin identifiers from the on-wire JSON / protobuf / CBOR field names. Use the overload that takes both:
map.remove(key, value)
Returns true if the entry was removed. Useful for atomic compare-and-delete semantics. buildString { ... } is an inline function that creates a StringBuilder, runs the lambda with it as this, and returns toString(). StringBuilder is the underlying type — use it directly only when reusing instances for performance.

Question 21 Kotlin Programming

What is a primary constructor in Kotlin?

const val declares a compile-time constant:
const val MAX_USERS = 100
Requirements: top-level or in an object / companion object, value must be a primitive or String, and the initializer must be a literal. Useful for annotations and switch-like when cases. If when is used as an expression (its result is assigned), the compiler requires an else branch. Without it, the code does not compile. As a statement, unmatched values are simply ignored. Use JetBrains' @NotNull annotation (or JSR-305 @Nonnull / AndroidX @NonNull) on the Java declaration. Kotlin then sees the type as non-nullable and rejects null assignments at compile time. Declared in the class header:
class User(val name: String, val age: Int)
It can have default values, visibility modifiers, and @Annotations but cannot contain code — use an init block for logic.

Question 22 Kotlin Programming

What is the Elvis operator in Kotlin?

The Elvis operator ?: provides a default value when an expression is null:
val len = name?.length ?: 0
If the left side is null, the right side is used.

Cold (flow { ... }): the producer runs only when a collector subscribes; each collector gets its own stream.
Hot (StateFlow, SharedFlow, Channel): emits whether or not anyone is collecting; multiple subscribers share or compete for values.

Kotlin distinguishes read-only and mutable collections:

List / MutableList
Set / MutableSet
Map / MutableMap

Use listOf(), mutableListOf(), mapOf(), mutableMapOf() to create them. A MatchResult? — the first match or null:
val match = Regex("""(\w+)@(\w+)""").find(email)
Access groups via match.groupValues[1] or destructuring: val (user, domain) = match.destructured.

Question 23 Kotlin Programming

What is a secondary constructor in Kotlin?

Defined inside the class body with the constructor keyword:
class User { constructor(name: String) : this(name, 0) { ... } }
Each secondary constructor must delegate to the primary via this(...) or to another secondary constructor. Kotlin provides rich functional operations:
val nums = listOf(1, 2, 3, 4, 5)

nums.filter { it > 2 } → [3, 4, 5]
nums.map { it * 2 } → [2, 4, 6, 8, 10]
nums.reduce { acc, i -> acc + i } → 15
nums.groupBy { it % 2 }

List: eager — every intermediate operation (map, filter) creates a new list.
Sequence: lazy — operations are fused and elements are produced one at a time.

Use sequences for large collections or when many chained operations would otherwise allocate many intermediate lists. Validating that a character is alphanumeric without manual ASCII math:
if (c.isLetterOrDigit()) append(c)
Other useful extensions: isDigit(), isLetter(), isUpperCase(), isWhitespace().

Question 24 Kotlin Programming

What does the SupervisorJob allow?

!! forces a non-null type that the smart cast system trusts throughout its scope. The thrown exception is KotlinNullPointerException (not NullPointerException), and the stack trace points to the !! site. A MatchResult? — the first match or null:
val match = Regex("""(\w+)@(\w+)""").find(email)
Access groups via match.groupValues[1] or destructuring: val (user, domain) = match.destructured. Yes. A companion object can implement interfaces:

class MyClass {
  companion object : Factory<MyClass> {
    override fun create(): MyClass = MyClass()
  }
}

This is a powerful pattern for factory methods. A SupervisorJob as the parent prevents child failures from cancelling siblings or the parent. This is the default for viewModelScope and GlobalScope in many setups. Use it for fire-and-forget tasks where one failure should not bring down the others.

Question 25 Kotlin Programming

What is the associateWith function?

const val: compile-time inlined into call sites, only primitives/Strings, only at top level or in objects.
val: read-only reference, evaluated at runtime, may have any type or custom getter, can be inside any class.

runCatching catches all Throwable (including Error), which is rarely what you want. Prefer try { } catch (e: IOException) { } for specific exception handling, and reserve runCatching for quick "may or may not work" chains. A lambda is an anonymous function written as a literal:
val square: (Int) -> Int = { x -> x * x }
If there is only one parameter, you can use it:
val square: (Int) -> Int = { it * it } associateWith builds a Map from a list's elements to values produced by a transform:
listOf("a", "b").associateWith { it.length } → {"a"=1, "b"=1}
It is the inverse of associateBy.

Question 26 Kotlin Programming

What does the reversed function do?

reversed() returns a new list with elements in reverse order. Use asReversed() on a MutableList for a live view that reflects later mutations. throw has return type Nothing. Because Nothing is a subtype of every other type, you can throw in an Elvis branch:
val name = input ?: throw IllegalArgumentException("name required") The by keyword implements the delegation pattern. A class can delegate interface implementation to another object:
class Derived(b: Base) : Base by b
All interface methods are forwarded to b automatically.

coroutineScope: child failure cancels siblings and propagates the exception.
supervisorScope: child failure is isolated; siblings and the scope continue. The parent only fails if you await the failed child.

Question 27 Kotlin Programming

What is a lambda expression in Kotlin?

A lambda is an anonymous function written as a literal:
val square: (Int) -> Int = { x -> x * x }
If there is only one parameter, you can use it:
val square: (Int) -> Int = { it * it } Call .toSet() or .toHashSet():
listOf(1, 2, 2, 3).toSet() → [1, 2, 3]
Use toMutableSet() if you need a mutable set. toHashSet() skips wrapper allocation by using the specific implementation. No. lateinit only works with non-null reference types — Int, Boolean, etc. cannot be lateinit. Use a nullable wrapper or a sentinel value instead. protected members are visible in the declaring class and its subclasses only. Unlike Java, they are not visible to other code in the same package.

Question 28 Kotlin Programming

What is the apply function ideal for?

Object initialization and configuration:

val dialog = AlertDialog.Builder(ctx).apply {
  setTitle("Hi")
  setMessage("World")
}.create()

Because it returns the receiver, it composes well in builder chains. Defined inside the class body with the constructor keyword:
class User { constructor(name: String) : this(name, 0) { ... } }
Each secondary constructor must delegate to the primary via this(...) or to another secondary constructor. Kotlin auto-generates get() and set() for properties. You can override them:
val name: String get() = "$first $last"
var password: String set(value) { if (value.length >= 8) field = value }
Inside a setter, the backing field is accessed via field. Use toIntOrNull() which returns null on parse failure:
val n = "42".toIntOrNull() // 42
val n = "abc".toIntOrNull() // null
Contrast with toInt() which throws NumberFormatException.

Question 29 Kotlin Programming

What does the windowed function do?

Delegates.observable triggers a callback whenever the property changes:

var name: String by Delegates.observable("initial") { prop, old, new ->
  println("$old -> $new")
}

Useful for reacting to state changes. @Serializable (from kotlinx.serialization) marks a class as eligible for automatic encodeToString/decodeFromString operations. The compiler plugin generates the serializer at compile time. throw has return type Nothing. Because Nothing is a subtype of every other type, you can throw in an Elvis branch:
val name = input ?: throw IllegalArgumentException("name required") windowed(size, step, partialWindows) produces overlapping or stepped slices of a collection:
(1..5).toList().windowed(3) → [[1,2,3], [2,3,4], [3,4,5]]
Add step to skip elements, partialWindows = true to keep short tails.

Question 30 Kotlin Programming

What is the apply scope function in Kotlin?

Only when the left-hand side expression is null. If the left side is non-null, the right side is not evaluated, which makes ?: useful for default values and lazy fallbacks. someNullable?.toString() never throws — if the receiver is null, the whole expression is null. This is safer than someNullable.toString(), which would throw NPE.

map: applies the transform to every element and keeps all results.
mapNotNull: applies the transform and discards any nulls from the result, returning a non-null list.

listOf("1", "x", "3").mapNotNull { it.toIntOrNull() } → [1, 3] apply executes a block on an object (referenced as this) and returns the object itself:

val user = User().apply {
  name = "Alice"
  age = 30
}

Ideal for object initialization.

Question 31 Kotlin Programming

What is the result type of try-catch in Kotlin?

A lambda is an anonymous function written as a literal:
val square: (Int) -> Int = { x -> x * x }
If there is only one parameter, you can use it:
val square: (Int) -> Int = { it * it } The try block is an expression. If all branches are present, the type is the common supertype of the try and catch result types:
val n = try { s.toInt() } catch (e: Exception) { -1 } Kotlin distinguishes read-only and mutable collections:

List / MutableList
Set / MutableSet
Map / MutableMap

Use listOf(), mutableListOf(), mapOf(), mutableMapOf() to create them. A platform type (e.g. String!) is generated when Kotlin calls Java code whose nullability annotations are missing or unclear. The compiler treats it as both nullable and non-nullable, leaving the choice to the caller — which can lead to NPEs at runtime.

Question 32 Kotlin Programming

What is a cold flow vs a hot flow?

emptyList<Int>() — a reusable read-only singleton (preferred for performance).
listOf<Int>() — also empty but allocates a wrapper.
mutableListOf<Int>() — empty and mutable.

Cold (flow { ... }): the producer runs only when a collector subscribes; each collector gets its own stream.
Hot (StateFlow, SharedFlow, Channel): emits whether or not anyone is collecting; multiple subscribers share or compete for values.

1) Property initializers and init blocks run in declaration order. 2) Secondary constructors run after delegation completes. Code in init always sees constructor parameters in scope. const val declares a compile-time constant:
const val MAX_USERS = 100
Requirements: top-level or in an object / companion object, value must be a primitive or String, and the initializer must be a literal. Useful for annotations and switch-like when cases.

Question 33 Kotlin Programming

What is a companion object's relationship to its class?

coroutineScope { ... } creates a child scope: all launched children complete (or are cancelled) before the block returns. Throws the first failure if any child fails. It is the structural way to wait for parallel work:
val (a, b) = coroutineScope { val x = async { fetchA() }; val y = async { fetchB() }; x.await() to y.await() } A backing field is generated only if you use the default accessor or use field inside a custom accessor. A computed property with no field reference is just a function with property syntax. zip pairs elements from two collections of equal length into a List<Pair<A,B>>:
listOf("a","b").zip(listOf(1,2)) → [(a,1), (b,2)]
Stops at the shorter collection. zipWithNext pairs adjacent elements within a single collection. A companion object is initialized when the outer class is loaded, and its members can be accessed as if they were static. Each class can have at most one companion object.

Question 34 Kotlin Programming

What is the noinline keyword used for?

cancel() sends a cancellation signal — the coroutine is cooperatively cancelled at the next suspension point. It throws CancellationException internally, which is treated as normal completion by coroutine machinery. To honor cancellation, suspending functions should call ensureActive() or other cancellable APIs. Any is the root of the Kotlin type hierarchy, equivalent to Object in Java. Every non-nullable type is a subtype of Any. Any? is the supertype of all types, including nullable ones. noinline tells the compiler not to inline a specific lambda parameter of an inline function:
inline fun foo(action: () -> Unit, noinline logger: () -> Unit) { ... }
This is needed when the lambda is stored or passed elsewhere. singleOrNull returns the only element of a collection, or null if there are zero or more than one. Useful for asserting uniqueness: users.singleOrNull { it.id == targetId }.

Question 35 Kotlin Programming

What is a Char.isLetterOrDigit check used for?

Validating that a character is alphanumeric without manual ASCII math:
if (c.isLetterOrDigit()) append(c)
Other useful extensions: isDigit(), isLetter(), isUpperCase(), isWhitespace(). Dispatchers determine which thread a coroutine runs on:

Dispatchers.Main — UI thread
Dispatchers.IO — optimized for I/O operations
Dispatchers.Default — CPU-intensive work
Dispatchers.Unconfined — not confined to any thread

getOrElse retrieves an element at an index (or by key for maps) or computes a fallback from a lambda:
map.getOrElse("missing") { defaultValue }
Preferable to ?: default when the default is expensive to compute. const val declares a compile-time constant:
const val MAX_USERS = 100
Requirements: top-level or in an object / companion object, value must be a primitive or String, and the initializer must be a literal. Useful for annotations and switch-like when cases.

Question 36 Kotlin Programming

What is the difference between CharSequence and String?

getOrPut(key) { computeDefault() } returns the value for key, computing and inserting the default via the lambda if the key is missing:
counts.getOrPut(word) { 0 } → existing count, or 0 inserted. String is a concrete, immutable sequence of Char. CharSequence is the interface implemented by String, StringBuilder, and StringBuffer. Library functions that only need to read chars should accept CharSequence for flexibility. Kotlin provides rich functional operations:
val nums = listOf(1, 2, 3, 4, 5)

nums.filter { it > 2 } → [3, 4, 5]
nums.map { it * 2 } → [2, 4, 6, 8, 10]
nums.reduce { acc, i -> acc + i } → 15
nums.groupBy { it % 2 }

with is a non-extension function that takes an object and a lambda. Inside the block, this refers to the object:

with(builder) {
  setTitle("Hello")
  setMessage("World")
}

Returns the lambda result. Best for calling multiple methods on an object.

Question 37 Kotlin Programming

What is smart casting in Kotlin?

After an is check, the compiler automatically casts the variable:

if (obj is String) {
  println(obj.length) // no explicit cast needed
}

This works with when, if, and && / || expressions. The !! operator converts a nullable type to a non-null type and throws a KotlinNullPointerException if the value is null:
val len = name!!.length
Use it only when you are absolutely certain the value is not null. chunked(size) splits a collection into lists of the given size:
(1..7).toList().chunked(3) → [[1,2,3], [4,5,6], [7]]
Useful for batching network calls or paginating a UI. internal members are visible anywhere in the same Gradle/IntelliJ module, but invisible from other modules. It is Kotlin's unit of encapsulation for libraries — a stronger default than public but less restrictive than protected.

Question 38 Kotlin Programming

How do you create an Array with a size and initializer in Kotlin?

Use the Array(size) { index -> ... } constructor:
val squares = Array(5) { i -> (i * i).toString() }
The lambda receives the index and is called for every position at construction time. 1) Property initializers and init blocks run in declaration order. 2) Secondary constructors run after delegation completes. Code in init always sees constructor parameters in scope.

step n controls the increment of any range.
downTo reverses the direction (descending range).

They can combine: for (i in 10 downTo 0 step 2) → 10, 8, 6, 4, 2, 0. protected members are visible in the declaring class and its subclasses only. Unlike Java, they are not visible to other code in the same package.

Question 39 Kotlin Programming

What is the singleOrNull function used for?

run executes a block where this refers to the object. It returns the lambda result:

val result = service.run {
  port = 8080
  connect()
}

Useful for object configuration and computing a result. runCatching { ... } wraps a block in a try/catch and returns a Result<T>:
runCatching { File("x").readText() }.getOrElse { "" }
You can chain .onSuccess { }, .onFailure { }, .getOrNull(), .getOrElse { }. singleOrNull returns the only element of a collection, or null if there are zero or more than one. Useful for asserting uniqueness: users.singleOrNull { it.id == targetId }.

Object expression: an anonymous class created on the fly: val o = object : Foo() { override fun bar() = 1 }
Object declaration: a named singleton: object Logger { fun log(m: String) = ... }

Object expressions are eager but local; declarations are lazy and global.

Question 40 Kotlin Programming

What is the associate function on collections?

Use toIntOrNull() which returns null on parse failure:
val n = "42".toIntOrNull() // 42
val n = "abc".toIntOrNull() // null
Contrast with toInt() which throws NumberFormatException. A suspend fun returns a single value. A Flow emits multiple values over time, is cold (no work until collected), and supports operators like map, filter, collect, combine, and debounce. associate returns a Map built by a transform that produces both key and value:
listOf(1,2,3).associate { it to it * 2 } → {1=2, 2=4, 3=6}
Last duplicate key wins. throw has return type Nothing. Because Nothing is a subtype of every other type, you can throw in an Elvis branch:
val name = input ?: throw IllegalArgumentException("name required")

Question 41 Kotlin Programming

What is the runCatching function in Kotlin?

runCatching { ... } wraps a block in a try/catch and returns a Result<T>:
runCatching { File("x").readText() }.getOrElse { "" }
You can chain .onSuccess { }, .onFailure { }, .getOrNull(), .getOrElse { }. buildString { ... } is an inline function that creates a StringBuilder, runs the lambda with it as this, and returns toString(). StringBuilder is the underlying type — use it directly only when reusing instances for performance.

step n controls the increment of any range.
downTo reverses the direction (descending range).

They can combine: for (i in 10 downTo 0 step 2) → 10, 8, 6, 4, 2, 0. A CoroutineScope defines the lifecycle of coroutines. When the scope is cancelled, all its coroutines are cancelled:
val scope = CoroutineScope(Dispatchers.IO)
Common scopes: GlobalScope, viewModelScope, lifecycleScope.

Question 42 Kotlin Programming

What is the difference between const val and val?

Kotlin has no checked exceptions. You can throw and catch any exception without declaring it. The compiler will not force callers of a function to catch or rethrow IOException, SQLException, etc. A backing field is generated only if you use the default accessor or use field inside a custom accessor. A computed property with no field reference is just a function with property syntax.

for ((k, v) in map) { ... } — destructured entry iteration.
map.forEach { (k, v) -> ... } — lambda form.
Iterate keys: for (k in map.keys). Values: for (v in map.values).

const val: compile-time inlined into call sites, only primitives/Strings, only at top level or in objects.
val: read-only reference, evaluated at runtime, may have any type or custom getter, can be inside any class.

Question 43 Kotlin Programming

How do you break out of a forEach lambda?

Destructuring lets you unpack an object into multiple variables in a single declaration:
val (name, age) = User("Alice", 30)
It relies on componentN() operator functions. Data classes provide these automatically. You cannot use break directly inside forEach. Options: use a normal for loop, use return@forEach to skip the current iteration, or wrap the work in run { ... } and use a labeled return@run. also executes a block on an object (referenced as it) and returns the object itself:

val list = mutableListOf(1, 2).also {
  println("Initial list: $it")
}

Best for side effects like logging or validation. sequenceOf(...) or sequence { yield(...); yieldAll(...) } produces a lazy iterable. Each element is computed on demand, allowing efficient chained operations on large or infinite streams.

Question 44 Kotlin Programming

How does the internal visibility modifier work?

"a,b,c,d".split(",", limit = 2) → ["a", "b,c,d"]
The limit parameter caps the number of parts returned; remaining delimiters are kept in the last element. Without limit, the default is 0 (no cap). Call .toSet() or .toHashSet():
listOf(1, 2, 2, 3).toSet() → [1, 2, 3]
Use toMutableSet() if you need a mutable set. toHashSet() skips wrapper allocation by using the specific implementation. coroutineScope { ... } creates a child scope: all launched children complete (or are cancelled) before the block returns. Throws the first failure if any child fails. It is the structural way to wait for parallel work:
val (a, b) = coroutineScope { val x = async { fetchA() }; val y = async { fetchB() }; x.await() to y.await() } internal members are visible anywhere in the same Gradle/IntelliJ module, but invisible from other modules. It is Kotlin's unit of encapsulation for libraries — a stronger default than public but less restrictive than protected.

Question 45 Kotlin Programming

What is the difference between map and mapNotNull?

Kotlin distinguishes read-only and mutable collections:

List / MutableList
Set / MutableSet
Map / MutableMap

Use listOf(), mutableListOf(), mapOf(), mutableMapOf() to create them.

map: applies the transform to every element and keeps all results.
mapNotNull: applies the transform and discards any nulls from the result, returning a non-null list.

listOf("1", "x", "3").mapNotNull { it.toIntOrNull() } → [1, 3] Kotlin auto-generates get() and set() for properties. You can override them:
val name: String get() = "$first $last"
var password: String set(value) { if (value.length >= 8) field = value }
Inside a setter, the backing field is accessed via field. Extension functions let you add new functions to existing classes without modifying their source code:
fun String.addExclamation(): String = this + "!"
Called as: "Hello".addExclamation() returns "Hello!".

Question 46 Kotlin Programming

What is the any type in Kotlin?

reduce: combines elements starting with the first one; throws if the collection is empty.
fold: like reduce but takes an explicit initial accumulator; safe for empty collections.

listOf(1,2,3).reduce { a, b -> a + b } → 6
listOf<Int>().fold(0) { a, b -> a + b } → 0 It returns the success value or rethrows the captured exception:
val data = runCatching { api.fetch() }.getOrThrow()
Useful when you want a Result-style chain to end in a thrown exception. Append a ? to the type declaration:
var name: String? = null
Without the ?, the compiler will reject any attempt to assign null. Any is the root of the Kotlin type hierarchy, equivalent to Object in Java. Every non-nullable type is a subtype of Any. Any? is the supertype of all types, including nullable ones.

Question 47 Kotlin Programming

What is the difference between open, abstract, and sealed classes?

Any is the root of the Kotlin type hierarchy, equivalent to Object in Java. Every non-nullable type is a subtype of Any. Any? is the supertype of all types, including nullable ones. String interpolation lets you embed expressions inside strings using $:
val name = "Alice"
println("Hello, $name!")
For complex expressions, use curly braces: "Length: ${name.length}"

open: can be inherited; not abstract, can be instantiated
abstract: cannot be instantiated; may have abstract and concrete members
sealed: like abstract but restricts subclasses to the same file/package

By default, Kotlin classes are final.

apply / also return the receiver (use to build and pass on the object).
let / run return the lambda result (use when you want to compute something new).

Choose based on what the chain needs to produce.

Question 48 Kotlin Programming

What is the difference between arrayListOf and mutableListOf?

Both return a mutable list, but:

arrayListOf returns a Java ArrayList directly (java.util.ArrayList).
mutableListOf returns the least specific mutable list type, allowing the implementation to be optimized (e.g. ArrayList, LinkedList on JVM).

== checks structural equality (calls equals())
=== checks referential equality (same object in memory)

val a = "hi"; val b = "hi"
a == b is true; a === b may be true due to string interning. A type alias provides an alternative name for an existing type:
typealias UserMap = Map<String, User>
typealias OnClick = (View) -> Unit
They simplify complex generic types and function type signatures without creating new types. associate returns a Map built by a transform that produces both key and value:
listOf(1,2,3).associate { it to it * 2 } → {1=2, 2=4, 3=6}
Last duplicate key wins.

Question 49 Kotlin Programming

What is a Regex in Kotlin and how is it used?

Call .toSet() or .toHashSet():
listOf(1, 2, 2, 3).toSet() → [1, 2, 3]
Use toMutableSet() if you need a mutable set. toHashSet() skips wrapper allocation by using the specific implementation. Construct with Regex("pattern") or "pattern".toRegex():
val r = Regex("""\d+""")
Use r.containsMatchIn(s), r.find(s), r.findAll(s), or r.replace(s, "x"). Nothing is a type with no instances. It is used for functions that never return — they always throw or terminate the process:
fun fail(msg: String): Nothing = throw IllegalStateException(msg)
Nothing is a subtype of every other type, so a Nothing expression can be used anywhere a return value is expected. It returns the success value or rethrows the captured exception:
val data = runCatching { api.fetch() }.getOrThrow()
Useful when you want a Result-style chain to end in a thrown exception.

Question 50 Kotlin Programming

What is the difference between arrayOf and listOf?

A MatchResult? — the first match or null:
val match = Regex("""(\w+)@(\w+)""").find(email)
Access groups via match.groupValues[1] or destructuring: val (user, domain) = match.destructured.

arrayOf(1, 2, 3) returns a Kotlin Array<Int> — boxed integers, fixed size, mutable contents.
listOf(1, 2, 3) returns a List<Int> — backed by an ArrayList at runtime, immutable view.

Structured concurrency ensures that coroutines are scoped to a parent. If the parent is cancelled or fails, all child coroutines are automatically cancelled. This prevents coroutine leaks and simplifies error handling. runCatching catches all Throwable (including Error), which is rarely what you want. Prefer try { } catch (e: IOException) { } for specific exception handling, and reserve runCatching for quick "may or may not work" chains.