Kotlin questions test the language features Android teams use every day, especially null safety and coroutines.
Below are 32 Kotlin questions with the correct answer and a short explanation, grouped from fresher to experienced level. Try each one before you open the answer.
What does this Kotlin code print when user is null?
val user: User? = null val name = user?.name ?: "Guest" println(name)
Answer: D. Guest
The safe call user?.name returns null when user is null instead of throwing. The Elvis operator ?: then returns the right-hand value when the left side is null, so the result is "Guest".
What does this Kotlin code print, and would the commented-out line compile if you removed the '//'?
val items = mutableListOf(1, 2) items.add(3) // items = mutableListOf(4) println(items)
Answer: A. It prints [1, 2, 3]; the commented line would not compile because items is a val
val means the reference cannot be reassigned, not that the object is immutable. A MutableList held in a val can still be changed with add(), so it prints [1, 2, 3]. Reassigning items to a new list is a compile error because the variable itself is read-only.
In Kotlin coroutines, what is the main difference between launch and async?
Answer: C. launch returns a Job for work with no result; async returns a Deferred whose result you get with await()
Both start a coroutine in a scope, and the dispatcher decides the thread. launch is for work where you do not need a value back and returns a Job you can cancel or join. async returns a Deferred, and await() suspends until its value is ready, which is handy for running several requests in parallel.
Which statement about Kotlin’s lateinit and by lazy is correct?
Answer: B. lateinit: a var set later; lazy: a val built on first use
lateinit var says "I will assign this non-null value before use", and reading it early throws UninitializedPropertyAccessException. It cannot be used with primitive types. by lazy runs its initializer once, on first access, and only works with val.
You want MyFragment.newInstance(id) callable without an instance, like a static method in Java. Where should it go?
Answer: D. In a companion object inside MyFragment
Members of a companion object are accessed through the class name. It is the usual place for factory functions and constants tied to a class. Add @JvmStatic if Java callers need a real static method.
What does marking a function with suspend do?
Answer: D. It can pause without blocking; it adds no thread
suspend means the function can pause at suspension points and resume later. Where it runs depends on the coroutine’s dispatcher. Blocking code inside a suspend function still blocks unless moved with withContext.
You need to sort and filter 2 lakh records in memory, which is CPU-heavy. Which dispatcher fits?
Answer: B. Dispatchers.Default
Dispatchers.Default is sized to the number of CPU cores and is meant for CPU-bound work. Dispatchers.IO allows many more threads for blocking calls such as file or network I/O. Main is for UI work.
What does this function do?
suspend fun loadConfig(file: File): String =
withContext(Dispatchers.IO) {
file.readText()
}Answer: A. Runs readText on an I/O thread and returns its result
withContext switches to the given dispatcher, runs the block, and returns its value to the caller, which resumes on its original dispatcher. This makes the function main-safe to call from UI code.
Inside a coroutine on the main dispatcher, why use delay(500) rather than Thread.sleep(500)?
Answer: D. delay suspends; sleep blocks the thread and UI
Thread.sleep blocks the thread, so on the main thread the UI cannot draw or respond. delay suspends the coroutine and frees the thread for other work, and it is also cancellable.
Inside a Unity coroutine, how do you pause for two seconds of game time without freezing the game?
Answer: C. yield return new WaitForSeconds(2f);
Yielding WaitForSeconds tells Unity to resume the coroutine after two seconds of scaled game time, while every other system keeps running. Thread.Sleep or a busy loop block the main thread and freeze the whole game. Use WaitForSecondsRealtime if the wait should ignore Time.timeScale.
Why put brackets around (Java OR Kotlin) in the string 'Android AND (Java OR Kotlin)'?
Answer: A. So OR is applied first, before AND
Brackets tell the engine which part to work out first. Here it finds profiles with Java or Kotlin, then keeps only those that also mention Android. Without brackets, engines may combine terms in an order you did not intend.
An Android ViewModel exposes screen state (loading, content or error) to a Compose screen. Which type is the usual choice, and why?
Answer: D. A StateFlow, because it always holds the latest value and gives it to new collectors immediately
Screen state should always have a current value, and a screen that starts collecting after rotation must get it right away. StateFlow holds one value, replays it to new collectors and skips equal values. Channels or SharedFlows suit one-off events, but they lose the current state for late collectors.
Why is collectAsStateWithLifecycle() usually preferred over collectAsState() when a Compose screen on Android reads a Flow from a ViewModel?
Answer: A. It stops collecting when the lifecycle drops below STARTED, such as when the app goes to the background, saving work and resources
collectAsState keeps collecting as long as the composable is in the composition, even when the app is in the background. collectAsStateWithLifecycle ties collection to the Android lifecycle, so upstream work such as location or database queries can pause. collectAsState still works; it is just less efficient on Android.
What happens to coroutines launched in viewModelScope when the user leaves the screen for good and the ViewModel is cleared?
Answer: D. They are cancelled automatically
viewModelScope is cancelled when the ViewModel is cleared (onCleared), which cancels all of its child coroutines. This prevents leaks and wasted work for a screen that no longer exists. Work that must outlive the screen, like an upload, belongs in WorkManager or an application-level scope.
A screen can be loading, show a list, or show an error message. Which Kotlin model makes impossible combinations unrepresentable?
Answer: D. A sealed interface with Loading, Content(items) and Error(msg)
Separate flags allow nonsense like loading and error both true. A sealed hierarchy holds exactly one state at a time, each with only the data it needs, and when forces the UI to handle every case.
Which declaration compiles?
Answer: A. const val MAX_RETRIES = 3 at top level
const val must be a compile-time constant of a primitive type or String, declared at top level or in an object or companion object. Its value is inlined at use sites. Values computed at runtime need plain val.
Why does this fail to compile, and what is a common fix?
class User { var name: String? = null }
fun show(user: User) {
if (user.name != null) {
println(user.name.length)
}
}Answer: B. name is a var that may change; copy it to a local val
The compiler only smart casts values it knows cannot change between the check and the use. A var property (or one with a custom getter or from another module) might change. Use val n = user.name, or user.name?.let { … }.
Two threads read a "by lazy" property at the same moment for the first time. With the default mode, what happens?
Answer: D. The initializer runs once; the other thread waits for it
The default LazyThreadSafetyMode.SYNCHRONIZED uses a lock so the block runs exactly once. PUBLICATION allows multiple runs but one value is kept, and NONE skips locking for single-thread use such as UI-only code.
You want to try fetching a location for up to 3 seconds and fall back to the last known one. Which call fits?
Answer: C. withTimeoutOrNull(3000) { fetch() } ?: lastKnown
withTimeoutOrNull cancels the block after the time limit and returns null, which pairs well with ?:. withTimeout instead throws TimeoutCancellationException, which you would need to catch.
A respawn coroutine never finishes. The object calls gameObject.SetActive(false) right after starting it. What happened?
Answer: A. Deactivating the GameObject stops all coroutines running on its MonoBehaviours
Coroutines are owned by the MonoBehaviour that started them. Deactivating the GameObject or destroying the component stops them, and reactivating does not restart them. Note that only setting enabled = false on the script does not stop them. Run the timer on a manager object that stays active instead.
A coroutine runs yield return null. When does it continue?
Answer: D. Next frame, after that frame's Update calls
yield return null waits one frame; Unity resumes the coroutine after all Update methods run in the next frame. WaitForFixedUpdate and WaitForEndOfFrame resume at other points in the loop.
Which profile does this search return?
("java" OR "kotlin") AND "spring" NOT "intern"Answer: A. A Kotlin developer who uses Spring, not an intern
The profile must contain Java or Kotlin, and must contain Spring, and must not contain "intern". Only the Kotlin developer using Spring, with no intern mention, meets all three conditions.
A Compose list item recomposes on every scroll frame even though its data did not change. The item takes a List<Tag> parameter from a regular Kotlin class. What is a likely cause?
Answer: C. The parameter type is considered unstable, so Compose cannot safely skip the item; use immutable collections or stable types and pass keys
Compose skips a composable only when it can prove all parameters are stable and equal. The standard List interface may be backed by a mutable list, so classes holding it can be treated as unstable. Using kotlinx immutable collections, marking types @Immutable or @Stable, and enabling strong skipping mode reduces needless recompositions. Use the Layout Inspector to check recomposition counts.
After the ViewModel is cleared, logs show this loop still logging errors over and over. Why?
viewModelScope.launch {
while (true) {
try {
delay(1000)
poll()
} catch (e: Exception) {
log(e)
}
}
}Answer: D. catch (e: Exception) also catches the CancellationException thrown by delay(), so the loop swallows cancellation and keeps going; rethrow it or catch only specific exceptions
Cancellation in coroutines works by throwing CancellationException at suspension points like delay. Catching all exceptions hides it, and every later delay throws again immediately, giving a fast loop that logs forever. Rethrow CancellationException, catch narrower types, or call ensureActive() in the catch block.
What does this print?
data class User(val id: Int) {
var name: String = ""
}
val a = User(1).apply { name = "Asha" }
val b = User(1).apply { name = "Ravi" }
println(a == b)Answer: D. true
Generated equals(), hashCode(), toString() and copy() use only properties declared in the primary constructor. name lives in the class body, so both objects compare equal on id alone. This surprises people using such objects in sets or diffing.
Why does this function need inline and reified?
inline fun <reified T> List<Any>.firstOfType(): T? =
firstOrNull { it is T } as T?Answer: A. Without reified, T is erased and "is T" is not allowed
On the JVM, generic types are erased at runtime, so a normal function cannot check "is T". An inline function with a reified type parameter is copied into the call site with the real type, making type checks and T::class possible.
viewModelScope uses Dispatchers.Main.immediate. What does "immediate" change?
Answer: C. Already on main, the code runs now instead of being queued
Dispatchers.Main posts work to the main looper even when you are already on it, adding a delay. Main.immediate runs the code right away in that case, so state updates from a click are applied in the same frame.
After this coroutine is cancelled, the server never gets the "release" call. Why, and what is the fix?
try {
api.lock(id)
doWork()
} finally {
api.release(id) // suspend fun
}Answer: C. Suspend calls throw once cancelled; use NonCancellable
Once cancelled, any suspending function that checks cancellation throws CancellationException at once, so api.release() never runs. withContext(NonCancellable) lets short cleanup code suspend. Keep such cleanup brief.
You need to ensure only one token refresh runs at a time, and the refresh is a suspend call. Why is a synchronized block a poor fit?
Answer: A. You cannot suspend inside synchronized; use Mutex.withLock
The compiler forbids suspension points inside synchronized blocks, and blocking a thread while waiting wastes dispatcher threads. kotlinx.coroutines Mutex suspends waiting coroutines instead, and withLock releases it even on exceptions.
A ViewModel retries after delay(30_000). How do you test it without waiting 30 real seconds?
Answer: B. Use runTest, where delays run on virtual time
runTest runs coroutines on a TestScheduler with virtual time, so delays are skipped. advanceTimeBy or advanceUntilIdle control progress. The ViewModel’s dispatcher must be a test dispatcher (for example Dispatchers.setMain).
A `sealed class PaymentState` has three subclasses: Idle, Loading and Failed. A switch expression handles only Idle and Loading. What happens?
Answer: B. The analyzer reports a compile error because the switch is not exhaustive
A sealed class can only be extended in its own library, so the compiler knows every subtype. Switch expressions over it must be exhaustive, and a missing case is a compile-time error. This catches forgotten UI states the moment a new subclass is added.
On many search tools, AND is processed before OR. What does this string actually return?
java OR kotlin AND spring
Answer: B. Anyone with Java, plus Kotlin people who also have Spring
Without brackets, AND binds first, so it reads as java OR (kotlin AND spring). Every Java profile appears, even without Spring. Adding brackets, (java OR kotlin) AND spring, gives the intended result.
Take a 15-question Kotlin MCQ test with a score at the end, or practise the full Kotlin question bank and earn points on the leaderboard.