easysafe call
What is the type of `length` after this safe-call chain?
val length = user?.address?.city?.lengthKotlin Interview Questions (505 to practise)
Kotlin is the default language for Android and a common Java replacement on the JVM. Coroutines are its defining feature.
Null safety and platform types, coroutine scopes and cancellation, suspend function semantics, inline and reified generics, and data class copy behaviour.
- Total questions
- 505
- Easy
- 63
- Medium
- 218
- Hard
- 224
Where it shows up: Android apps, JVM back ends adopting Kotlin, and multiplatform mobile teams.
Sample Kotlin questions
Twenty real Kotlin questions from the library, code snippet included. Nothing here is paraphrased for search engines. It is the same text a signed-in user sees.
mediumsuspend functions usage
What is the effect of calling a suspend function inside withContext(Dispatchers.IO) { ... }?
suspend fun loadData(): String = withContext(Dispatchers.IO) {
blockingDbCall()
}easysafe call
What is the difference between `?.let { }` running its block versus not running it?
val name: String? = null
name?.let { println(it.uppercase()) }mediumFlow cold streams
What does this snippet print, demonstrating how operators and collection interact on a cold Flow?
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
fun main() = runBlocking {
val flow = (1..3).asFlow()
.map { println("map $it"); it * 2 }
println("flow built")
flow.collect { println("got $it") }
}mediumtailrec functions
Both functions are marked tailrec and each one's recursive call is the last operation. What does the compiler actually do?
tailrec fun isEven(n: Int): Boolean =
if (n == 0) true else isOdd(n - 1)
tailrec fun isOdd(n: Int): Boolean =
if (n == 0) false else isEven(n - 1)hardstructured concurrency Job tree
Given this structured-concurrency code, what happens to the parent coroutine and the sibling child when `childB` throws?
suspend fun run() = coroutineScope {
val childA = launch { delay(1000); println("A") }
val childB = launch { throw IllegalStateException("boom") }
}hardFlow backpressure buffer conflate
A fast producer feeds a slow collector through `buffer(capacity = 2)`. Once the buffer is full, what happens to the producer's next `emit`, and through what concurrency primitive is this realized?
flow {
repeat(5) { emit(it); println("emitted $it") }
}.buffer(2).collect {
delay(100)
println("collected $it")
}mediumcoroutine dispatchers context
What is the relationship between the coroutine that runs the launch block and its parent's context in this code?
import kotlinx.coroutines.*
val scope = CoroutineScope(Dispatchers.Default + CoroutineName("parent"))
fun demo() {
scope.launch(Dispatchers.IO) {
// what context applies here?
}
}hardcoroutine cancellation cooperation
Why does a tight CPU loop like `while (i < n) { i++ }` inside a coroutine fail to stop when the coroutine is cancelled, even though `delay` would have stopped immediately?
launch {
var i = 0
while (i < 1_000_000_000) { i++ }
println("done")
}hardVolatile and atomics on JVM
Consider a `@Volatile var flag = false` and a non-volatile `var data = 0`, with one thread writing `data = 42; flag = true` and another doing `if (flag) print(data)`. Which JMM property makes the reader guaranteed to see `data == 42`, and what would break it?
// Writer thread:
data = 42
flag = true
// Reader thread:
if (flag) println(data)mediumtailrec functions
Why does this `tailrec` function compile and run without a stack overflow for large `n`, and what would break the optimization?
tailrec fun factorial(n: Long, acc: Long = 1L): Long {
return if (n <= 1L) acc
else factorial(n - 1, acc * n)
}hardstructured concurrency Job tree
A coroutine launched inside a `coroutineScope { }` block throws an unhandled exception. Regarding how structured concurrency propagates this through the Job tree, which statement is accurate?
suspend fun work() = coroutineScope {
launch { delay(50); throw RuntimeException("boom") }
launch { delay(1000); println("sibling") }
}easysafe call
What is the result of this expression using the safe-call operator?
val text: String? = null
val result = text?.uppercase()easydata classes
Which property is NOT included in the auto-generated equals(), hashCode(), and toString() of this data class?
data class Account(val id: Int) {
var balance: Int = 0
}easyextension functions
What happens when an extension function has the same signature as an existing member function?
class Box {
fun show() = "member"
}
fun Box.show() = "extension"
println(Box().show())easyval vs var
Why does this code fail to compile?
val count = 5
count = 6easydata classes
What does this code print?
data class Point(val x: Int, val y: Int)
val a = Point(1, 2)
val b = Point(1, 2)
println(a == b)easywhen expressions
What happens when you match multiple comma-separated values in a single when branch?
fun kind(c: Char) = when (c) {
'a', 'e', 'i', 'o', 'u' -> "vowel"
else -> "consonant"
}
println(kind('e'))easydata classes
For a data class, what does the compiler automatically generate?
data class User(val id: Int, val name: String)easydata classes
What does `copy(age = 31)` return here?
data class User(val name: String, val age: Int)
val a = User("Ana", 30)
val b = a.copy(age = 31)Sign in to answer
Everything above is free to read. Answering needs a free account.
We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the answer options and the worked explanation for every Kotlin question stay behind a free account. Signing in is free and takes a few seconds.
Kotlin topics covered
58 distinct Kotlin topics are tagged across the library. These are the real topic labels stored on the questions, not a hand-written list.
- Flow cold streams (20)
- StateFlow SharedFlow (18)
- inline functions (18)
- structured concurrency Job tree (17)
- Volatile and atomics on JVM (17)
- the Continuation interface (17)
- inline class boxing rules (16)
- value class codegen (16)
- suspend functions usage (15)
- Flow backpressure buffer conflate (15)
- class delegation by (15)
- coroutine cancellation cooperation (14)
- property delegation lazy (14)
- sealed class hierarchies (14)
- crossinline noinline (14)
- suspend compiled to state machine (13)
- data classes (11)
- coroutine dispatchers context (11)
- coroutines basics launch async (11)
- COROUTINE_SUSPENDED sentinel (11)
- platform types mechanics (11)
- JVM memory model happens-before (11)
- type erasure on the JVM (11)
- continuation-passing style transform (11)
- generics variance in out (11)
- type-safe builders DSLs (10)
- exception handling in coroutines (10)
- JVM bytecode for inline functions (10)
- tailrec functions (9)
- Java interop JvmStatic JvmName (9)
- invokedynamic for lambdas (9)
- reified type parameters (8)
- safe call (7)
- star projections (7)
- companion object as a JVM class (7)
- dispatch virtual vs static (7)
- null safety and double bang (6)
- operator overloading (6)
- higher-order function composition (6)
- sealed classes basics (4)
- elvis operator (4)
- lambdas and trailing lambdas (4)
- default and named arguments (4)
- extension functions (3)
- val vs var (3)
- string templates (3)
- when expressions (2)
- scope functions let apply run (2)
- collections map filter (2)
- destructuring declarations (2)
- Continuation interface (2)
- companion object basics (1)
- smart casts (1)
- nullable collection handling (1)
- ranges and for (1)
- generics variance (out) (1)
- null safety (1)
- double bang (1)
Search and filter every Kotlin question
…
Difficulty