...
Pregătire interviuri

100 de întrebări de interviu Kotlin, cu răspunsuri

Întrebările despre Kotlin care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Kotlin (Android): primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 51junior
  • 34mid
  • 15senior
  • 137 minde citit
Întrebări de interviu Kotlin cu răspunsuri

La un interviu pentru un rol în care se lucrează cu Kotlin, fie pe Android, fie pe backend, limbajul este verificat separat de framework-uri. Intervievatorii pun întrebări de teorie (null safety, tipuri de clase, generice, coroutines), dar mai ales întrebări cu cod scurt: „ce afișează”, „unde e bug-ul”, „scrie o funcție care...”. Des apare și o probă de live coding sau o temă acasă, unde se urmărește dacă scrii Kotlin idiomatic sau Java cu altă sintaxă.

La nivel junior se așteaptă să stăpânești sintaxa, null safety, clasele și operațiile pe colecții și să citești corect cod simplu. La nivel mid se adaugă înțelegerea mecanismelor: cum se rezolvă extensiile, ce returnează scope functions, varianța genericelor, propagarea erorilor și anularea în coroutines, operatorii de Flow și interoperabilitatea cu Java. Pentru senior contează costurile la rulare, deciziile de design și capacitatea de a explica și de a conduce schimbări în echipă.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi întrebarea și încearcă să răspunzi singur, eventual rulând codul, apoi compară cu răspunsul scurt și cu explicația detaliată. Secțiunea „de ce se întreabă” îți arată ce urmărește intervievatorul și greșelile frecvente. Întrebările de bază despre Android, Jetpack Compose și ViewModel sunt pe pagina dedicată meseriei de Android Developer.

Sintaxă, tipuri și control flow

1 Junior

Codul de mai jos compilează? Ce afișează și ce s-ar întâmpla dacă ai decomenta ultima linie?

KOTLIN
val numbers = mutableListOf(1, 2)
numbers.add(3)
println(numbers)
// numbers = mutableListOf(4)

Răspuns scurt: Compilează și afișează [1, 2, 3]. val interzice doar reatribuirea referinței, nu modificarea obiectului spre care arată, așa că linia comentată ar da eroare de compilare.

val declară o referință care nu mai poate fi reatribuită după inițializare, echivalentul unei variabile final din Java. Asta nu spune nimic despre obiectul spre care arată referința. mutableListOf creează un MutableList, deci add modifică lista existentă, iar referința numbers rămâne aceeași.

Linia numbers = mutableListOf(4) încearcă să schimbe referința, iar compilatorul o respinge cu mesajul „Val cannot be reassigned”.

Dacă vrei ca nici conținutul să nu poată fi schimbat prin această referință, combini val cu un tip read-only:

KOTLIN
val numbers: List<Int> = listOf(1, 2, 3)
// numbers.add(4)  // eroare: List nu are add

Regula practică în Kotlin: începi mereu cu val și treci la var doar când chiar ai nevoie să reatribui. Codul cu val e mai ușor de urmărit, pentru că știi că valoarea nu se schimbă pe parcurs, iar compilatorul poate face smart cast mai des pe variabile locale val. Separat, alegi între colecții read-only (List, Map) și mutabile (MutableList, MutableMap) după cine are voie să modifice datele.

Ce urmărește intervievatorul: Verifică dacă faci diferența între imutabilitatea referinței și imutabilitatea obiectului. Mulți candidați spun că val face lista „constantă”.

Eroarea, în practică:'val' cannot be reassigned

2 Junior

Ce tip deduce compilatorul pentru fiecare variabilă?

KOTLIN
val a = 42
val b = 3_000_000_000
val c = 42L
val d = 3.14
val e = 3.14f
val f = 'K'

Răspuns scurt: a e Int, b e Long pentru că valoarea nu încape în Int, c e Long datorită sufixului L, d e Double, e e Float, iar f e Char.

Kotlin are inferență de tip: dacă inițializezi variabila, nu trebuie să scrii tipul. Pentru literalii întregi regula e: implicit Int, dar dacă valoarea depășește intervalul Int (aproximativ plus sau minus 2,1 miliarde), tipul devine Long. De aceea 3_000_000_000 este Long. Sublinierile sunt doar pentru lizibilitate și nu schimbă valoarea.

Pentru numere cu virgulă, literalul simplu e Double; pentru Float ai nevoie de sufixul f sau F. Char se scrie între apostrofuri, iar String între ghilimele.

Poți forța tipul scriindu-l explicit, iar compilatorul acceptă literalul dacă încape:

KOTLIN
val small: Byte = 100      // OK
val big: Long = 42         // OK, literalul devine Long
// val wrong: Int = 42L    // eroare: Long nu se convertește implicit
val u = 42u                // UInt, tip fără semn

Pe JVM, tipurile Int, Long, Double nenulabile se compilează la primitive (int, long, double), iar variantele nulabile (Int?) sau folosite în generice devin obiecte (Integer). Asta contează pentru performanță în bucle mari și pentru comparațiile de identitate.

Ce urmărește intervievatorul: Intervievatorul verifică regulile de inferență pentru literali. Greșeala tipică e să crezi că orice număr întreg fără sufix e Int.

Eroarea, în practică:Use 'L' instead of 'l'Value out of range

3 Junior

Ce afișează codul următor și de ce?

KOTLIN
val a = "Kotlin"
val b = StringBuilder("Kot").append("lin").toString()
println(a == b)
println(a === b)

Răspuns scurt: Afișează true și apoi false. == compară conținutul prin equals, iar === verifică dacă cele două referințe arată spre același obiect din memorie.

În Kotlin, == este egalitate structurală: compilatorul îl traduce în a?.equals(b) ?: (b === null), deci e sigur și când una dintre valori e null. Pentru String, equals compară caracterele, așa că a == b dă true.

=== este egalitate referențială: întreabă dacă e același obiect. a vine din pool-ul de literali, iar b e un String nou creat la rulare de StringBuilder, deci sunt obiecte diferite și rezultatul e false.

Diferența față de Java e importantă: în Java == pe obiecte compară referințe, iar în Kotlin compară conținut. Un programator venit din Java care scrie === „din reflex” va avea bug-uri.

Pentru tipurile numerice, === e o capcană suplimentară:

KOTLIN
val x: Int? = 1000
val y: Int? = 1000
println(x == y)   // true
println(x === y)  // de regulă false: obiecte Integer diferite

Pentru valori între -128 și 127, JVM-ul refolosește aceleași obiecte Integer, așa că rezultatul pare să „funcționeze” în teste mici. Compilatorul dă avertisment la identitate pe tipuri numerice tocmai pentru că nu are sens. În practică folosești === foarte rar, de exemplu în implementarea lui equals (if (this === other) return true).

Ce urmărește intervievatorul: Se verifică dacă știi că semantica lui == e inversată față de Java. Greșeala tipică e confuzia dintre cele două operatori sau credința că === e „mai strict” la fel ca în JavaScript.

4 Junior

Cum funcționează string templates în Kotlin? Ce afișează codul și cum scrii un text pe mai multe rânduri?

KOTLIN
val name = "Ana"
val items = listOf("pâine", "lapte")
println("Salut, $name! Ai ${items.size} produse: ${items.joinToString()}")
println("Preț: ${'$'}5")

Răspuns scurt: Afișează Salut, Ana! Ai 2 produse: pâine, lapte și Preț: $5. $nume inserează o variabilă, ${expresie} inserează orice expresie, iar textul pe mai multe rânduri se scrie cu ghilimele triple.

Un string template inserează valori direct în text. $name merge pentru un identificator simplu; pentru orice altceva (apel de metodă, proprietate, calcul) folosești acolade: ${items.size}. Compilatorul transformă totul într-o concatenare eficientă, așa că nu e nevoie de String.format sau de + repetat.

Ca să scrii un dolar literal, în stringurile obișnuite poți folosi \$, iar varianta ${'$'} merge peste tot, inclusiv în stringurile raw, unde backslash-ul nu e caracter de escape.

Pentru text pe mai multe rânduri folosești raw strings, cu ghilimele triple. În ele nu există secvențe de escape, deci sunt utile pentru JSON, SQL sau expresii regulate:

KOTLIN
val sql = """
    SELECT name, email
    FROM users
    WHERE active = 1
""".trimIndent()

val regex = Regex("""\d{3}-\d{4}""")

trimIndent() elimină indentarea comună și primul și ultimul rând gol, iar trimMargin() taie tot ce e înainte de un caracter-marcaj (implicit |). Templates funcționează și în raw strings, deci poți scrie $name în interiorul lor.

Ce urmărește intervievatorul: Verifică sintaxa de bază folosită zilnic. Greșeala tipică: "$items.size", care afișează lista urmată de textul .size în loc de dimensiune.

Eroarea, în practică:Unsupported escape sequence

5 Junior

Kotlin nu are operatorul ternar cond ? a : b din Java. Cum scrii int max = a > b ? a : b; în Kotlin și ce înseamnă că if este o expresie?

Răspuns scurt: Scrii val max = if (a > b) a else b. În Kotlin if și when sunt expresii, adică produc o valoare, iar ultima expresie din fiecare ramură devine rezultatul.

În Java, if este o instrucțiune: execută ceva, dar nu are valoare. În Kotlin, if este o expresie, deci îl poți pune în dreapta unui =, într-un return sau ca argument de funcție. De aceea operatorul ternar nu mai e necesar.

KOTLIN
val max = if (a > b) a else b

val label = if (score >= 90) {
    println("Excelent")
    "A"            // ultima expresie din bloc este valoarea
} else if (score >= 70) {
    "B"
} else {
    "C"
}

fun sign(n: Int) = when {
    n > 0 -> "pozitiv"
    n < 0 -> "negativ"
    else -> "zero"
}

Când folosești if ca expresie, ramura else este obligatorie, altfel compilatorul nu știe ce valoare să dea când condiția e falsă. La fel, when folosit ca expresie trebuie să fie exhaustiv.

Tipul rezultatului este cel mai apropiat supertip comun al ramurilor: dacă o ramură dă Int și alta String, rezultatul e Any, ceea ce de obicei semnalează o greșeală. Dacă o ramură aruncă o excepție, ea are tipul Nothing și nu influențează tipul final. Atenție: ?: din Kotlin (Elvis) arată ca o bucată din ternar, dar face altceva: alege valoarea din dreapta doar când cea din stânga e null.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că gândești în expresii, nu în instrucțiuni. Greșeala tipică e confuzia dintre Elvis și ternar.

Eroarea, în practică:'if' must have both main and 'else' branches

6 Junior

Ce afișează fiecare linie?

KOTLIN
for (i in 1..5 step 2) print(i)
println()
for (i in 5 downTo 1) print(i)
println()
for (i in 0 until 3) print(i)
println()
for (i in 0..<3) print(i)
println()
println(7 in 1..10)
println('c' in 'a'..'f')

Răspuns scurt: Afișează 135, 54321, 012, 012, true, true. .. include capătul, until și ..< îl exclud, downTo numără descrescător, iar step stabilește pasul.

Un range (interval) în Kotlin este un obiect cu un capăt de început și unul de sfârșit, peste care poți itera sau pe care îl poți folosi cu in.

  • 1..5 este interval închis: include 1 și 5.
  • 0 until 3 și 0..<3 sunt intervale semideschise, fără capătul de sus. Operatorul ..< este stabil din Kotlin 1.9 și e mai lizibil la iterarea peste indici.
  • 5 downTo 1 creează o progresie descrescătoare. Atenție: 5..1 este un interval gol, iar for (i in 5..1) nu execută nimic, fără nicio eroare.
  • step 2 sare din doi în doi; pasul trebuie să fie pozitiv, chiar și cu downTo.

Intervalele merg pentru Int, Long, Char și, pentru verificări in, pentru orice tip Comparable (de exemplu "b" in "a".."c").

Pentru iterarea peste colecții, ai variante mai sigure decât indicii scriși de mână:

KOTLIN
val names = listOf("Ana", "Dan")
for (i in names.indices) println("$i: ${names[i]}")
for ((i, name) in names.withIndex()) println("$i: $name")
repeat(3) { println("rândul $it") }

for (i in 1..n) nu creează în spate un obiect IntRange: compilatorul îl transformă într-o buclă simplă cu contor, deci nu există cost de performanță.

Ce urmărește intervievatorul: Verifică dacă știi exact unde se termină fiecare tip de interval. Greșelile tipice: 5..1 crezut descrescător și 0..list.size care produce IndexOutOfBoundsException.

Eroarea, în practică:Step must be positive, was: 0

7 Junior

De ce nu compilează codul de mai jos și cum îl corectezi? Ce face 'a' + 1?

KOTLIN
val i: Int = 10
val l: Long = i

Răspuns scurt: Kotlin nu face conversii implicite între tipuri numerice, nici măcar de la Int la Long. Scrii val l: Long = i.toLong(). 'a' + 1 dă caracterul 'b', pentru că Char nu este număr, dar are operatorul plus(Int).

În Java, long l = i; merge prin lărgire automată (widening). Kotlin a renunțat intenționat la asta: conversiile ascunse produc surprize, de exemplu la comparații între Integer și Long boxate. Așa că orice conversie se face explicit, cu funcții de tipul toLong(), toInt(), toDouble().

KOTLIN
val i = 10
val l: Long = i.toLong()
val d = i / 4.0          // Double: operatorii aritmetici au supraîncărcări mixte
val back = 3.99.toInt()  // 3: trunchiere, nu rotunjire
val big = 300.toByte()   // 44: depășire, se păstrează doar ultimii 8 biți

Operațiile aritmetice între tipuri diferite sunt permise pentru că Int are supraîncărcări plus(Double), plus(Long) și așa mai departe, iar rezultatul are tipul „mai larg”.

Char nu este tip numeric în Kotlin. 'a' + 1 apelează Char.plus(Int) și dă 'b', dar val n: Int = 'a' nu compilează. Pentru codul numeric folosești 'a'.code (din Kotlin 1.5, înlocuiește toInt() depreciat), iar pentru cifra reprezentată de caracter, '7'.digitToInt(), care dă 7.

Pentru texte, "12".toInt() aruncă NumberFormatException dacă textul nu e valid, iar toIntOrNull() întoarce null și e de preferat când datele vin de la utilizator.

Ce urmărește intervievatorul: Verifică dacă știi că Kotlin nu are lărgire implicită și că Char nu e număr. Candidații veniți din Java se blochează des aici la live coding.

Eroarea, în practică:Initializer type mismatchAssignment type mismatch

8 Junior

Ce este Unit în Kotlin și prin ce diferă de void din Java?

Răspuns scurt: Unit este un tip real care are o singură valoare, tot Unit. Funcțiile fără rezultat util returnează implicit Unit, iar pentru că e un tip obișnuit, poate fi folosit în generice, de exemplu în () -> Unit.

void din Java nu este un tip propriu-zis: nu poți avea o variabilă void și nu îl poți folosi ca argument generic (de aceea există Void cu V mare și return null). În Kotlin, Unit este un object declarat în biblioteca standard, cu o singură instanță.

Când scrii o funcție fără tip de return, compilatorul pune Unit:

KOTLIN
fun log(msg: String) {           // echivalent cu : Unit
    println(msg)
}

val result = log("salut")
println(result)                  // kotlin.Unit

Avantajul apare în generice și în tipurile funcție. Un parametru onClick: () -> Unit acceptă orice lambda, iar o clasă generică Result<T> poate fi folosită ca Result<Unit> pentru operații care reușesc sau eșuează fără să întoarcă date. Nu e nevoie de cazuri speciale ca în Java.

La compilare pentru JVM, funcțiile care returnează Unit devin metode void, deci nu există cost la rulare și apelurile din Java arată natural.

Unit nu trebuie confundat cu Nothing: Unit înseamnă „funcția s-a terminat normal și nu are nimic interesant de dat”, iar Nothing înseamnă „funcția nu se termină niciodată normal” (aruncă o excepție sau rulează la infinit).

Ce urmărește intervievatorul: Se verifică înțelegerea sistemului de tipuri dincolo de sintaxă. Greșeala tipică e să spui că Unit e „același lucru cu void” fără să știi că e o valoare reală.

9 Junior

Ce afișează codul următor?

KOTLIN
outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (j == 2) continue@outer
        if (i == 3) break@outer
        print("$i$j ")
    }
}

Răspuns scurt: Afișează 11 21 . continue@outer trece direct la următorul i, iar la i == 3 și j == 1, break@outer oprește ambele bucle înainte de print.

Kotlin permite etichete (labels) pe bucle: scrii un nume urmat de @ în fața buclei, apoi break@nume sau continue@nume acționează asupra acelei bucle, nu doar asupra celei mai interioare.

Parcurgem pas cu pas:

  • i = 1, j = 1: nicio condiție nu e adevărată, se afișează 11 .
  • i = 1, j = 2: continue@outer abandonează bucla interioară și trece la i = 2.
  • i = 2, j = 1: se afișează 21 ; la j = 2 din nou continue@outer.
  • i = 3, j = 1: prima condiție e falsă, a doua e adevărată, iar break@outer termină tot.

Etichetele sunt utile când cauți ceva într-o structură imbricată și vrei să te oprești la prima potrivire. Totuși, de multe ori codul devine mai clar dacă muți bucla într-o funcție separată și folosești return:

KOTLIN
fun findPair(grid: List<List<Int>>, target: Int): Pair<Int, Int>? {
    for ((r, row) in grid.withIndex())
        for ((c, v) in row.withIndex())
            if (v == target) return r to c
    return null
}

Aceeași sintaxă cu @ se folosește și pentru return@forEach în lambda și pentru this@Outer în clase interioare, deci merită înțeleasă bine.

Ce urmărește intervievatorul: Verifică urmărirea atentă a fluxului de control și cunoașterea etichetelor. Greșeala tipică e să crezi că continue@outer continuă bucla interioară.

Eroarea, în practică:Label does not denote a reachable loop

10 Mid

Ce este tipul Nothing? Explică de ce compilează codul de mai jos.

KOTLIN
fun fail(msg: String): Nothing = throw IllegalStateException(msg)

fun parsePort(s: String): Int {
    val port = s.toIntOrNull() ?: fail("Port invalid: $s")
    return port
}

Răspuns scurt: Nothing este tipul unei expresii care nu se termină niciodată normal: aruncă o excepție sau nu se oprește. Fiind subtip al oricărui tip, fail(...) se potrivește în dreapta lui ?:, iar port rămâne Int.

Nothing este bottom type: nu are nicio valoare și este subtip al tuturor tipurilor. O funcție cu tipul de return Nothing promite că nu va returna niciodată. throw este și el o expresie de tip Nothing.

În exemplu, s.toIntOrNull() are tipul Int?. Elvis alege dreapta când stânga e null. Dreapta are tipul Nothing, iar supertipul comun dintre Int și Nothing este Int, deci port e Int nenulabil. Compilatorul știe și că după un apel Nothing codul e inaccesibil, așa că îl poate marca drept „unreachable code”.

Unde mai apare Nothing în practică:

  • TODO("de implementat") returnează Nothing și aruncă NotImplementedError, deci poți lăsa corpul unei funcții neterminat fără să inventezi o valoare.
  • error("mesaj") aruncă IllegalStateException și are tot tipul Nothing.
  • val x = null are tipul Nothing?, singurul tip al cărui unic membru e null.
  • emptyList() poate fi List<Nothing>, care, datorită covarianței lui List<out E>, se potrivește oriunde se cere List<String> sau List<User>.
KOTLIN
sealed interface Result<out T>
data class Ok<T>(val value: T) : Result<T>
data class Err(val message: String) : Result<Nothing>

Aici Err poate fi folosit ca Result<User> sau Result<Int> fără parametru generic propriu.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi sistemul de tipuri, nu doar sintaxa. Greșeala tipică e confuzia între Nothing și Unit.

Eroarea, în practică:NotImplementedError: An operation is not implemented

11 Mid

Ce afișează fiecare linie?

KOTLIN
println(7 / 2)
println(7 / 2.0)
println(-7 % 3)
println((-7).mod(3))
println(0.1 + 0.2 == 0.3)
println(Int.MAX_VALUE + 1)

Răspuns scurt: Afișează 3, 3.5, -1, 2, false și -2147483648. Împărțirea între întregi trunchiază, % păstrează semnul deîmpărțitului, mod dă rest nenegativ pentru divizor pozitiv, Double nu reprezintă exact 0,1, iar Int se depășește fără excepție.

Fiecare linie arată o capcană clasică:

  • 7 / 2 este împărțire între Int, deci rezultatul e Int și se trunchiază spre zero: 3. Dacă un operand e Double, rezultatul e 3.5.
  • % (funcția rem) dă un rest cu semnul deîmpărțitului, deci -7 % 3 este -1. Funcția mod, disponibilă din Kotlin 1.5, dă restul matematic, cu semnul divizorului: (-7).mod(3) este 2. Parantezele contează: -7.mod(3) înseamnă -(7.mod(3)), adică -1, pentru că minusul unar are prioritate mai mică decât apelul de funcție.
  • 0.1 + 0.2 dă 0.30000000000000004, pentru că numerele binare în virgulă mobilă nu pot reprezenta exact 0,1. Nu compari Double cu ==, ci cu o toleranță: abs(a - b) < 1e-9.
  • Int.MAX_VALUE + 1 face overflow silențios și trece la valoarea minimă. JVM-ul nu aruncă excepție. Dacă depășirea e posibilă, folosești Long sau Math.addExact, care aruncă ArithmeticException.

Pentru bani nu folosești niciodată Double. Variantele corecte sunt sume întregi în bani (cenți) ca Long sau java.math.BigDecimal:

KOTLIN
val price = BigDecimal("19.99")
val total = price * BigDecimal(3)   // 59.97, exact

Ce urmărește intervievatorul: Verifică atenția la detalii numerice care produc bug-uri reale în facturare și statistici. Greșelile tipice: -7.mod(3) fără paranteze și compararea Double cu ==.

Eroarea, în practică:ArithmeticException: / by zeroArithmeticException: integer overflow

12 Senior

Ce s-a schimbat odată cu Kotlin 2.0 și compilatorul K2? La ce te uiți când migrezi un proiect de pe Kotlin 1.9?

Răspuns scurt: Kotlin 2.0 face din K2 compilatorul implicit: un frontend rescris, mai rapid, cu smart casts mai inteligente și o arhitectură comună pentru toate platformele. La migrare verifici pluginurile de compilator, kapt, avertismentele noi și codul care depindea de comportamente vechi.

K2 este noul frontend al compilatorului Kotlin, devenit stabil și implicit în Kotlin 2.0. Frontend-ul face analiza codului (rezolvarea numelor, inferența tipurilor), iar K2 îl reunifică pentru JVM, JS, Native și Wasm, ceea ce face multiplatform mai consistent.

Schimbări vizibile pentru programatori:

  • Smart casts mai bune. De exemplu, o verificare salvată într-o variabilă locală e folosită ulterior:
KOTLIN
fun speak(animal: Any) {
    val isCat = animal is Cat
    if (isCat) animal.purr()   // K2 face smart cast; K1 nu
}

La fel, după if (x is A || x is B) tipul devine supertipul comun, iar variabilele locale modificate în lambda-uri ale funcțiilor inline sunt tratate mai precis.

  • Compilare mai rapidă, mai ales în faza de analiză, deși câștigul depinde de proiect.
  • Unele erori care înainte erau doar avertismente sau treceau neobservate devin erori, iar câteva cazuri ambigue de rezolvare se comportă diferit.

La migrare:

  • Verifici că toate pluginurile de compilator sunt compatibile: Compose (al cărui compilator s-a mutat în repository-ul Kotlin din 2.0), serialization, all-open, Parcelize și pluginurile proprii.
  • kapt rulează în mod de compatibilitate; e un moment bun să muți procesoarele de adnotări pe KSP.
  • Treci întâi pe ultima versiune 1.9, rezolvi avertismentele de depreciere, apoi actualizezi și rulezi tot setul de teste.
  • Ai opțiunea de a compila temporar cu languageVersion mai vechi pentru module problematice.

Ce urmărește intervievatorul: La nivel senior se verifică dacă urmărești evoluția limbajului și știi riscurile unei actualizări de compilator. Răspunsurile vagi de tipul „e mai rapid” fără detalii de migrare sunt slabe.

Null safety

13 Junior

Ce afișează programul?

KOTLIN
data class Address(val city: String?)
data class User(val name: String, val address: Address?)

fun main() {
    val users = listOf(
        User("Ana", Address("Cluj")),
        User("Dan", null),
        User("Ion", Address(null))
    )
    for (u in users) {
        println(u.address?.city?.uppercase() ?: "necunoscut")
    }
}

Răspuns scurt: Afișează CLUJ, necunoscut, necunoscut. Lanțul de apeluri sigure se oprește la primul null și dă null, iar Elvis înlocuiește rezultatul cu textul implicit.

Operatorul de apel sigur ?. evaluează partea din dreapta doar dacă receptorul nu e null; altfel, întreaga expresie devine null. Într-un lanț, primul null „scurtcircuitează” restul.

  • Pentru Ana: address există, city este "Cluj", uppercase() dă "CLUJ".
  • Pentru Dan: address e null, deci u.address?.city e null și nici uppercase() nu se mai apelează. Elvis dă "necunoscut".
  • Pentru Ion: address există, dar city e null. Lanțul se oprește la al doilea ?..

Tipul expresiei u.address?.city?.uppercase() este String?, iar după ?: "necunoscut" devine String. Compilatorul te obligă să folosești ?. pe fiecare verigă nulabilă: u.address.city nu compilează, pentru că address are tipul Address?.

Lanțurile lungi de ?. sunt corecte, dar uneori ascund o problemă de modelare: dacă aproape toate câmpurile sunt nulabile, poate datele ar trebui validate la intrare și transformate în tipuri nenulabile. De exemplu, un DTO venit din rețea poate avea câmpuri nulabile, iar modelul folosit în restul aplicației, nu.

Elvis are prioritate mică, deci a?.b ?: c se citește (a?.b) ?: c. Pentru expresii mai complexe, parantezele explicite ajută la citire.

Ce urmărește intervievatorul: Verifică dacă înțelegi scurtcircuitarea lanțului ?.. Mulți candidați cred că al doilea ?. e inutil sau că lanțul aruncă excepție la null.

Eroarea, în practică:Only safe (?.) or non-null asserted (!!.) callsOperator call is prohibited on a nullable receiver

14 Junior

Cum transformi în siguranță un text în număr și o valoare Any într-un tip concret, fără să riști excepții? Ce face codul de mai jos?

KOTLIN
val inputs = listOf("12", "abc", "7", "")
val numbers = inputs.mapNotNull { it.toIntOrNull() }

val x: Any = "text"
val n: Int? = x as? Int

Răspuns scurt: toIntOrNull() întoarce null în loc să arunce NumberFormatException, iar mapNotNull păstrează doar rezultatele valide: [12, 7]. as? este cast sigur: dă null dacă tipul nu se potrivește, deci n este null.

Funcțiile cu sufixul OrNull sunt varianta Kotlin pentru „încearcă și spune-mi dacă n-a mers”. În loc de un try/catch în jurul lui toInt(), primești un Int? pe care îl tratezi cu operatorii de null safety:

KOTLIN
val age = readLine()?.toIntOrNull() ?: 0
val port = config["port"]?.toIntOrNull()
    ?: error("Lipsește portul sau nu e număr")

Există aceeași familie pentru alte tipuri și colecții: toDoubleOrNull, toLongOrNull, firstOrNull, getOrNull(index), maxOrNull, singleOrNull.

mapNotNull combină transformarea și filtrarea: aplică funcția și elimină rezultatele null, deci tipul final este List<Int>, nu List<Int?>.

Pentru tipuri, as face cast nesigur și aruncă ClassCastException dacă obiectul nu are tipul cerut. as? face cast sigur și întoarce null:

KOTLIN
fun describe(x: Any): String {
    val s = x as? String ?: return "nu e text"
    return "text de ${s.length} caractere"
}

De multe ori, is cu smart cast sau when (x) { is String -> ... } e mai lizibil decât as?. Ca regulă, codul care primește date din exterior (formulare, fișiere, API-uri) folosește variantele OrNull, iar excepțiile rămân pentru situațiile cu adevărat neașteptate.

Ce urmărește intervievatorul: Se verifică dacă tratezi intrările invalide fără excepții. Greșeala tipică: try { s.toInt() } catch (e: Exception) pe fiecare valoare.

Eroarea, în practică:NumberFormatException: For input stringClassCastException: cannot be cast to class

15 Junior

Ce excepție apare când operatorul !! întâlnește null? Când este acceptabil să-l folosești și ce alternative ai?

Răspuns scurt: Apare NullPointerException. !! e acceptabil doar când ești sigur că valoarea nu poate fi null și compilatorul nu poate demonstra asta; în rest preferi ?:, requireNotNull, checkNotNull sau o verificare explicită.

x!! spune compilatorului „știu eu că nu e null”. Dacă te înșeli, primești un NullPointerException exact pe linia cu !!. Practic, reintroduci în cod problema pe care Kotlin încearcă să o elimine.

Cazuri în care !! e rezonabil:

  • În teste, unde un null neașteptat trebuie să pice testul oricum.
  • Când o invariantă e garantată, dar compilatorul nu o poate vedea. Chiar și atunci există aproape mereu o variantă mai expresivă.

Alternative mai bune:

KOTLIN
// mesaj clar și tipul excepției potrivit
val user = requireNotNull(repo.find(id)) { "Utilizatorul $id nu există" }   // IllegalArgumentException
val token = checkNotNull(session.token) { "Sesiunea nu e autentificată" }     // IllegalStateException
val name = input ?: error("Lipsește numele")

// pentru map-uri, în loc de map[key]!!
val price = prices.getValue("mere")   // NoSuchElementException cu mesaj clar

// pentru proprietăți var nulabile
val current = selected ?: return

Avantajul acestor variante este că mesajul spune ce invariantă a fost încălcată, iar codul arată intenția. Un !! dintr-un stack trace nu îți spune nimic despre cauză.

Un semnal de alarmă în code review este !! repetat pe aceeași variabilă sau mult !! după o conversie automată din Java. De obicei înseamnă că tipurile nu sunt modelate bine: fie valoarea ar trebui să fie nenulabilă de la început, fie codul trebuie să trateze explicit cazul null.

Ce urmărește intervievatorul: Intervievatorul vrea să audă că !! e o excepție, nu o unealtă obișnuită. Răspunsul slab e „îl folosesc ca să scap de eroarea de compilare”.

Eroarea, în practică:Only safe (?.) or non-null asserted (!!.) callsjava.lang.NullPointerException

16 Junior

Care e diferența dintre List<String?>, List<String>? și List<String?>?? Cum lucrezi comod cu ele?

Răspuns scurt: List<String?> este o listă sigur existentă care poate conține elemente null. List<String>? este o listă care poate lipsi, dar elementele ei nu sunt null. List<String?>? combină ambele.

Semnul întrebării se aplică tipului lângă care stă. La generice, nulabilitatea listei și nulabilitatea elementelor sunt independente:

KOTLIN
val a: List<String?> = listOf("Ana", null, "Dan")
val b: List<String>? = null
val c: List<String?>? = listOf(null)

Funcții utile pentru fiecare caz:

KOTLIN
val names: List<String> = a.filterNotNull()           // [Ana, Dan]
val lengths = a.mapNotNull { it?.length }             // [3, 3]
val safe: List<String> = b.orEmpty()                  // [] în loc de null
val count = b?.size ?: 0
val first = b?.firstOrNull()

for (name in b.orEmpty()) println(name)               // fără if separat
if (!b.isNullOrEmpty()) println(b.first())            // smart cast la List<String>

În practică, regula sănătoasă este să eviți colecțiile nulabile în modelele tale. O listă goală spune deja „nu am elemente”, iar null adaugă o a doua stare de „nimic” care trebuie tratată peste tot. Colecțiile nulabile apar de obicei la margine: JSON cu câmpuri opționale sau API-uri Java. Acolo le transformi cât mai devreme cu orEmpty() și filterNotNull().

Elementele null dintr-o listă au uneori sens, de exemplu un tabel cu celule goale, dar de cele mai multe ori un tip dedicat sau o clasă sealed descrie mai bine situația.

Ce urmărește intervievatorul: Verifică precizia în citirea tipurilor generice nulabile. Greșeala tipică este să crezi că List<String>? permite elemente null.

Eroarea, în practică:Null cannot be a value of a non-null type

17 Junior

Cum funcționează funcțiile isNullOrEmpty() și orEmpty() pe un String?? Scrie o funcție extensie proprie pe un tip nulabil.

Răspuns scurt: Sunt funcții extensie definite pe receptor nulabil (String?), deci se pot apela direct, fără ?., iar în interiorul lor this poate fi null. Poți scrie la fel fun String?.orDash() = if (isNullOrBlank()) "-" else this.

O funcție extensie poate fi declarată pe un tip nulabil. Atunci o apelezi pe orice valoare de acel tip, inclusiv null, iar funcția decide ce face cu null. Biblioteca standard folosește des acest mecanism:

KOTLIN
val s: String? = null
println(s.isNullOrEmpty())   // true
println(s.isNullOrBlank())   // true, și pentru "   "
println(s.orEmpty().length)  // 0
println(s.toString())        // "null": toString e definit pe Any?

O extensie proprie:

KOTLIN
fun String?.orDash(): String =
    if (this.isNullOrBlank()) "-" else this

fun main() {
    val phone: String? = null
    println("Telefon: ${phone.orDash()}")   // Telefon: -
    println("Oraș: ${"Iași".orDash()}")     // Oraș: Iași
}

În ramura else, compilatorul face smart cast de la String? la String. Funcția isNullOrBlank are un contract care îi spune compilatorului că, dacă rezultatul e false, receptorul nu e null.

Asemenea extensii sunt utile pentru afișare și pentru valori implicite, dar nu trebuie abuzat: dacă fiecare tip din proiect are câte trei extensii nulabile, înseamnă că null circulă prea adânc prin cod. Atenție și la toString() pe nulabil: dă textul "null", care ajunge ușor într-un UI sau într-un fișier exportat.

Ce urmărește intervievatorul: Verifică dacă știi că extensiile pot avea receptor nulabil și cum funcționează smart cast-ul în ele. Mulți candidați cred că orice apel pe String? cere ?..

18 Junior

Completează funcția astfel încât să iasă imediat dacă utilizatorul sau emailul lipsesc, fără if imbricate și fără !!.

KOTLIN
data class User(val name: String, val email: String?)

fun sendWelcome(user: User?) {
    // ...
    println("Trimit email la ...")
}

Răspuns scurt: Folosești Elvis cu return: val email = user?.email ?: return. După această linie, email are tipul String și poți lucra cu el fără alte verificări.

return și throw sunt expresii de tip Nothing în Kotlin, deci pot sta în dreapta lui ?:. Asta permite un stil de ieșire timpurie (early return) foarte compact:

KOTLIN
fun sendWelcome(user: User?) {
    val email = user?.email ?: return
    println("Trimit email la $email pentru ${user.name}")
}

De ce compilează user.name fără ?.? Dacă execuția a trecut de prima linie, user?.email nu a fost null, deci nici user nu era null. Compilatorul face smart cast pentru user la User, pentru că e un parametru (deci nu se poate schimba).

Același tipar merge și în alte forme:

KOTLIN
val email = user?.email ?: throw IllegalArgumentException("Email lipsă")

for (line in lines) {
    val value = line.toIntOrNull() ?: continue   // sare peste rândurile invalide
    total += value
}

val config = loadConfig() ?: return Result.failure(ConfigMissing())

Avantajul față de if (user != null) { if (user.email != null) { ... } } este că logica principală rămâne nedentată și cazurile de eroare sunt tratate sus, unde se văd. Dezavantajul posibil: un ?: return silențios poate ascunde o eroare reală. Dacă lipsa emailului e o situație anormală, e mai bine să o semnalezi (log, excepție, rezultat de eroare) decât să ieși fără urmă.

Ce urmărește intervievatorul: Se verifică stilul idiomatic de tratare a lui null. Greșeala tipică e piramida de if-uri sau folosirea lui !! după o verificare.

Eroarea, în practică:actual type is 'String?', but 'String' was expected

19 Mid

Unde e bug-ul în codul de mai jos? Ce se afișează pentru greet("Ana") dacă findNickname întoarce null?

KOTLIN
fun findNickname(name: String): String? = null

fun greet(name: String?) {
    name?.let {
        println("Salut, $it")
        findNickname(it)
    } ?: run {
        println("Nume lipsă")
    }
}

Răspuns scurt: Se afișează ambele mesaje: „Salut, Ana” și „Nume lipsă”. let întoarce valoarea ultimei expresii, adică null de la findNickname, iar Elvis execută run și în acest caz. Corect e un if (name != null) ... else ....

Tiparul x?.let { ... } ?: run { ... } e folosit des ca înlocuitor pentru if/else, dar nu este echivalent. Elvis nu se uită dacă x a fost null, ci dacă rezultatul întregii expresii din stânga e null. Iar rezultatul lui let este valoarea ultimei expresii din lambda.

În exemplu, pentru "Ana":

1. name?.let rulează lambda, se afișează „Salut, Ana”. 2. Ultima expresie, findNickname(it), dă null, deci tot let dă null. 3. Elvis vede null și rulează run, afișând „Nume lipsă”.

Bug-ul apare doar pentru anumite date, deci trece ușor de teste. Variante corecte:

KOTLIN
fun greet(name: String?) {
    if (name != null) {
        println("Salut, $name")
        findNickname(name)
    } else {
        println("Nume lipsă")
    }
}

// sau, dacă vrei neapărat let:
name?.also { println("Salut, $it") } ?: println("Nume lipsă")

also întoarce receptorul, care în acea ramură nu e null, deci Elvis se execută doar când name e null.

Regula: ?.let { } ?: ... e potrivit când lambda chiar produce o valoare pe care o folosești (val len = s?.let { it.trim().length } ?: 0). Pentru „fă asta dacă există, altfel fă altceva”, un if e mai clar și mai sigur.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce returnează let și cum lucrează Elvis. E o greșeală întâlnită des în cod real, pe care mulți candidați nu o observă.

20 Mid

De ce nu compilează codul de mai jos, deși verifici null chiar înainte? Cum îl repari?

KOTLIN
class Profile(var bio: String?)

fun printBio(p: Profile) {
    if (p.bio != null) {
        println(p.bio.length)
    }
}

Răspuns scurt: bio este o proprietate var a altei clase, deci valoarea se poate schimba între verificare și folosire, de exemplu din alt thread. Compilatorul refuză smart cast-ul. Repari copiind valoarea într-un val local sau cu p.bio?.let { ... }.

Smart cast înseamnă că, după o verificare (!= null, is), compilatorul tratează automat variabila ca având tipul mai precis. El face asta doar când poate garanta că valoarea nu se schimbă între verificare și folosire.

Smart cast funcționează pentru:

  • variabile locale val;
  • variabile locale var care nu sunt modificate între verificare și folosire și nu sunt capturate într-o lambda care le modifică;
  • proprietăți val din același modul, fără getter personalizat și care nu sunt open.

Nu funcționează pentru:

  • proprietăți var (alt cod poate scrie între timp);
  • proprietăți open sau cu getter personalizat (getterul poate întoarce altceva la fiecare apel);
  • proprietăți declarate în alt modul (implementarea se poate schimba fără recompilarea ta).

Soluții:

KOTLIN
fun printBio(p: Profile) {
    val bio = p.bio           // citire unică
    if (bio != null) println(bio.length)
}

fun printBio2(p: Profile) {
    p.bio?.let { println(it.length) }
}

Ambele citesc proprietatea o singură dată, deci sunt corecte și în prezența concurenței. Pentru o variabilă partajată între thread-uri, copia locală nu rezolvă sincronizarea, dar elimină măcar riscul ca valoarea să devină null între verificare și folosire.

Kotlin 2.0 (K2) a extins cazurile în care smart cast funcționează, dar regula de bază pentru var din alte clase a rămas.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce există regula, nu doar soluția. Răspunsul slab e „pun !!”.

Eroarea, în practică:Smart cast to 'String' is impossibleSmart cast impossible: variable mutated in closure

21 Mid

De ce nu compilează prima funcție, iar a doua da? Ce înseamnă T : Any?

KOTLIN
fun <T> save(map: MutableMap<String, Any>, key: String, value: T) {
    map[key] = value
}

fun <T : Any> saveSafe(map: MutableMap<String, Any>, key: String, value: T) {
    map[key] = value
}

Răspuns scurt: Un parametru generic fără limită are implicit limita superioară Any?, deci T poate fi un tip nulabil și value poate fi null. T : Any restrânge T la tipuri nenulabile, așa că valoarea se poate pune într-un map de Any.

Când scrii <T>, compilatorul îl tratează ca <T : Any?>. Asta înseamnă că oricine poate apela save(map, "k", null) cu T = Nothing? sau save<String?>(...). Map-ul acceptă doar Any, deci atribuirea nu este sigură și compilatorul o respinge.

Cu T : Any, apelurile cu tipuri nulabile nu mai compilează:

KOTLIN
saveSafe(map, "age", 30)        // OK
val maybe: String? = null
// saveSafe(map, "x", maybe)    // eroare: String? nu respectă limita Any

Distincția contează când scrii funcții generice reutilizabile: de exemplu un cache, un repository sau o extensie de tipul fun <T : Any> T?.orThrow(): T.

Din Kotlin 1.7 există și definitely non-nullable types, scrise T & Any. Ele permit ca T să fie nulabil în general, dar ca un anumit parametru sau rezultat să fie garantat nenulabil:

KOTLIN
fun <T> elvisLike(x: T, y: T & Any): T & Any = x ?: y

Sintaxa e folosită mai ales la suprascrierea metodelor generice din Java adnotate cu @NotNull, unde înainte nu exista o variantă corectă.

În interiorul unei funcții cu <T>, o variabilă de tip T poate fi null chiar dacă nu vezi ? nicăieri. Dacă apelezi value.hashCode() merge doar pentru că există extensii definite pe Any?.

Ce urmărește intervievatorul: Verifică dacă știi limita implicită Any? a genericelor. Mulți candidați presupun că T fără ? este automat nenulabil.

22 Senior

Kotlin garantează la compilare că o proprietate val name: String nu e null. În ce situații poate ajunge totuși null acolo la rulare și cum te protejezi?

Răspuns scurt: Prin cod care ocolește compilatorul Kotlin: apeluri din Java, deserializare prin reflecție (de exemplu Gson), apelul unei metode open din constructor înainte de inițializare sau lateinit necitit corect. Te protejezi validând datele la granițe și folosind biblioteci care respectă constructorii Kotlin.

Null safety este o garanție a compilatorului Kotlin, nu a JVM-ului. Codul care nu trece prin verificările lui o poate încălca.

Cazuri reale:

  • Apeluri din Java. Pentru parametrii nenulabili ai funcțiilor publice, compilatorul inserează verificări (Intrinsics.checkNotNullParameter). Dacă Java trimite null, primești imediat un NullPointerException cu mesajul „Parameter specified as non-null is null”. E bine că eroarea apare la graniță, dar tot e un crash.
  • Deserializare prin reflecție. Gson poate crea obiecte fără să apeleze constructorul (prin Unsafe). Dacă JSON-ul nu are câmpul name, proprietatea String rămâne null, iar excepția apare mult mai târziu, departe de cauză. kotlinx.serialization sau Moshi cu suport Kotlin respectă constructorul și nulabilitatea și dau o eroare clară la parsare.
  • Ordinea inițializării. Un constructor de clasă de bază care apelează o metodă open suprascrisă va rula codul subclasei înainte ca proprietățile ei să fie inițializate:
KOTLIN
open class Base { init { describe() }; open fun describe() {} }
class Child : Base() {
    val label: String = "copil"
    override fun describe() { println(label.length) }  // NPE: label încă e null
}
  • lateinit citit înainte de atribuire aruncă UninitializedPropertyAccessException.

Protecție: validezi la intrare (DTO nulabil, apoi mapare la modelul de domeniu), adaugi adnotări de nulabilitate pe codul Java (JSpecify, JetBrains), nu apelezi metode open din constructori și eviți reflecția care ocolește constructorii. Opțiuni precum -Xno-param-assertions elimină verificările de la granițe și nu sunt recomandate.

Ce urmărește intervievatorul: La nivel senior se verifică înțelegerea limitelor garanțiilor limbajului. Candidații slabi răspund că „în Kotlin nu poate exista NPE”.

Eroarea, în practică:lateinit property has not been initializedParameter specified as non-null is null

Funcții, lambda și extensii

Exersează capitolul cu exerciții reale: Curs Kotlin pentru începători →
23 Junior

Ce afișează apelurile de mai jos? Cum ajută parametrii cu valori implicite și argumentele cu nume față de supraîncărcarea din Java?

KOTLIN
fun greet(name: String, greeting: String = "Salut", punctuation: String = "!") =
    "$greeting, $name$punctuation"

println(greet("Ana"))
println(greet("Ana", punctuation = "."))
println(greet(greeting = "Bună", name = "Dan"))

Răspuns scurt: Afișează Salut, Ana!, Salut, Ana. și Bună, Dan!. Valorile implicite înlocuiesc mai multe variante supraîncărcate ale aceleiași funcții, iar argumentele cu nume permit să sari peste parametri și să-i dai în orice ordine.

Funcția din exemplu are corp de expresie (expression body): după = urmează direct rezultatul, iar tipul de return (String) e dedus. E forma preferată pentru funcții scurte.

În Java, pentru a oferi variante cu mai puțini parametri, scrii mai multe metode supraîncărcate care se apelează una pe alta. În Kotlin declari o singură funcție cu valori implicite. Valorile pot fi expresii și pot folosi parametrii anteriori: fun range(from: Int, to: Int = from + 10).

Argumentele cu nume fac apelurile lizibile, mai ales când ai mai mulți parametri de același tip:

KOTLIN
createUser(name = "Ana", isAdmin = false, sendEmail = true)
// față de createUser("Ana", false, true), unde nu știi ce înseamnă fiecare boolean

Reguli de reținut:

  • După un argument cu nume poți folosi argumente poziționale doar dacă sunt în ordinea corectă; în practică, odată ce ai început cu nume, continui cu nume.
  • Numele parametrilor devin parte din API: dacă redenumești un parametru într-o bibliotecă, apelurile cu nume ale altora nu mai compilează.
  • Java nu vede valorile implicite. Dacă funcția trebuie apelată din Java, adaugi @JvmOverloads, care generează supraîncărcările necesare.

Valorile implicite sunt evaluate la fiecare apel, deci fun log(time: Long = System.currentTimeMillis()) dă ora apelului, nu ora la care s-a încărcat clasa.

Ce urmărește intervievatorul: Se verifică dacă scrii funcții Kotlin idiomatice. Greșeala tipică e să scrii supraîncărcări ca în Java sau să nu știi de @JvmOverloads.

Eroarea, în practică:No value passed for parameterMixing named and positional arguments

24 Junior

Ce rezultat dă apelul de mai jos și ce face steluța din fața lui arr?

KOTLIN
fun sumAll(vararg nums: Int): Int = nums.sum()

val arr = intArrayOf(1, 2, 3)
println(sumAll(*arr, 10))

Răspuns scurt: Afișează 16. vararg permite un număr variabil de argumente, care în funcție ajung ca IntArray. Steluța este spread operator: desface un tablou existent în argumente separate.

Un parametru vararg acceptă zero sau mai multe valori. În interiorul funcției, nums are tipul IntArray pentru vararg nums: Int și Array<out T> pentru un tip generic sau obiect, de exemplu vararg names: String devine Array<out String>.

KOTLIN
sumAll()              // 0
sumAll(5)             // 5
sumAll(1, 2, 3)       // 6

Dacă ai deja valorile într-un tablou, nu-l poți trimite direct, pentru că funcția așteaptă elemente individuale. Spread operatorul * îl desface și poți combina mai multe surse într-un singur apel: sumAll(*arr, 10, *intArrayOf(4)).

Pentru o listă, o convertești întâi la tablou: sumAll(*list.toIntArray()). Spread-ul face o copie a tabloului, deci pe colecții foarte mari și în bucle fierbinți are un cost.

Reguli:

  • O funcție poate avea un singur parametru vararg.
  • Dacă vararg nu e ultimul parametru, cei de după se dau cu nume: fun format(vararg parts: String, separator: String) se apelează format("a", "b", separator = "-").
  • Funcții standard ca listOf, setOf, mapOf sau arrayOf folosesc vararg, de aceea poți scrie listOf(1, 2, 3).

Din Java, o funcție Kotlin cu vararg se vede ca o metodă cu parametru variabil obișnuit (int...), deci interoperabilitatea e directă.

Ce urmărește intervievatorul: Verifică o funcționalitate de sintaxă des folosită și interacțiunea cu tablourile. Mulți candidați uită de spread și încearcă să trimită tabloul direct.

25 Junior

Explică sintaxa lambda din exemplu: ce este it, ce înseamnă trailing lambda și ce valoare întoarce o lambda?

KOTLIN
val nums = listOf(3, 8, 1)
val doubled = nums.map { it * 2 }
val sum = nums.fold(0) { acc, n -> acc + n }
val labels = nums.mapIndexed { _, n -> "nr. $n" }

Răspuns scurt: it este numele implicit al parametrului când lambda are unul singur. Trailing lambda înseamnă că, dacă ultimul parametru e o funcție, lambda se scrie după paranteze. O lambda întoarce valoarea ultimei expresii, fără return.

O lambda este o funcție anonimă scrisă între acolade: parametrii, săgeata ->, apoi corpul. { x: Int, y: Int -> x + y } este forma completă. Când tipurile se pot deduce din context, le omiți.

Convenții de sintaxă:

  • it: dacă lambda are exact un parametru, poți omite declararea lui și îl folosești ca it. Pentru lambda imbricate sau logică mai lungă e mai clar să-i dai un nume: users.filter { user -> user.isActive }.
  • Trailing lambda: dacă ultimul parametru al funcției e un tip funcție, lambda se poate scrie în afara parantezelor. fold(0) { acc, n -> acc + n } e același lucru cu fold(0, { acc, n -> acc + n }). Dacă lambda e singurul argument, parantezele dispar: map { it * 2 }.
  • _ marchează un parametru pe care nu-l folosești, ca indexul din mapIndexed.
  • Valoarea de return: ultima expresie din corp. Un return simplu în lambda nu face ce te aștepți (iese din funcția exterioară, dacă e permis); pentru a ieși din lambda folosești return@map.
KOTLIN
val parse: (String) -> Int = { s ->
    val trimmed = s.trim()
    trimmed.toIntOrNull() ?: 0     // valoarea întoarsă
}

Pentru lambda cu mai multe linii, ultima expresie trebuie să aibă tipul cerut. Dacă ultima linie e un println, rezultatul este Unit, ceea ce produce erori de tip greu de citit.

Ce urmărește intervievatorul: Intervievatorul verifică fluența cu sintaxa folosită pe fiecare rând de cod Kotlin. Greșeala tipică e un return scris în lambda fără etichetă.

26 Junior

Ce afișează codul și ce înseamnă ::isEven? Ce tip are fiecare variabilă?

KOTLIN
fun isEven(n: Int) = n % 2 == 0

val check: (Int) -> Boolean = ::isEven
val square: (Int) -> Int = { it * it }

println(listOf(1, 2, 3, 4).filter(check).map(square))

Răspuns scurt: Afișează [4, 16]. ::isEven este o referință la funcție: transformă funcția declarată într-o valoare de tip (Int) -> Boolean, care poate fi transmisă mai departe la fel ca o lambda.

În Kotlin funcțiile sunt valori de prim rang: au tipuri și pot fi stocate în variabile, trimise ca argumente sau returnate. Tipul funcție se scrie (Parametri) -> Rezultat: (Int) -> Boolean, (String, Int) -> Unit, () -> String.

O valoare de tip funcție se poate obține în două moduri:

  • dintr-o lambda: { it * it };
  • dintr-o referință cu :: la o funcție existentă: ::isEven.

Tipuri de referințe utile:

KOTLIN
val len = String::length              // (String) -> Int, referință la proprietate
val parse = String::toIntOrNull       // (String) -> Int?
val makeUser = ::User                 // referință la constructor: (String) -> User
val printer = System.out::println     // referință legată (bound) de un obiect

val names = listOf("ana", "dan").map(String::uppercase)

Referințele sunt utile când logica există deja ca funcție cu nume: filter(::isEven) se citește mai bine decât filter { isEven(it) }.

O valoare de tip funcție se apelează cu paranteze, check(4), sau cu check.invoke(4). Un tip funcție poate fi și nulabil, ((Int) -> Int)?, caz în care îl apelezi cu f?.invoke(4), pentru că f?.(4) nu e sintaxă validă.

Pentru tipuri funcție complicate, un typealias face semnăturile mai lizibile: typealias Validator = (String) -> Boolean.

Ce urmărește intervievatorul: Verifică înțelegerea funcțiilor ca valori, baza programării funcționale în Kotlin. Mulți candidați nu știu că pot face referință la constructori sau proprietăți.

27 Junior

Ce afișează codul de mai jos?

KOTLIN
fun makeCounter(): () -> Int {
    var count = 0
    return { ++count }
}

fun main() {
    val a = makeCounter()
    val b = makeCounter()
    println(a())
    println(a())
    println(b())
}

Răspuns scurt: Afișează 1, 2, 1. Fiecare apel al lui makeCounter creează propria variabilă count, iar lambda returnată o capturează și o modifică. Acesta este un closure.

Un closure este o funcție care ține minte variabilele din contextul în care a fost creată, chiar și după ce acel context s-a terminat. Lambda { ++count } folosește count, declarată în makeCounter. Când funcția se termină, variabila nu dispare, pentru că lambda încă are nevoie de ea.

a și b provin din apeluri diferite, deci fiecare are propriul count. a() crește contorul lui a la 1, apoi la 2, iar b() pornește de la propriul 0 și dă 1.

Diferența importantă față de Java: în Java, o lambda poate captura doar variabile „efectiv finale”. În Kotlin poți captura și modifica un var. Compilatorul îl împachetează într-un obiect mic (de exemplu Ref.IntRef), pe care lambda îl ține prin referință.

Consecințe practice:

  • Dacă lambda este rulată din mai multe thread-uri, variabila capturată este stare partajată fără sincronizare, deci ai race conditions.
  • O lambda care capturează un obiect mare îl ține în memorie cât timp trăiește lambda. Un callback înregistrat și neșters poate ține în viață un ecran întreg.
KOTLIN
val buttons = (1..3).map { i -> { println("buton $i") } }
buttons.forEach { it() }   // buton 1, buton 2, buton 3

Aici fiecare iterație are propriul i, deci nu apare problema clasică din JavaScript cu var în bucle.

Ce urmărește intervievatorul: Se verifică înțelegerea captării variabilelor, care contează pentru bug-uri de concurență și de memorie. Răspunsul greșit tipic este 1, 2, 3.

28 Mid

Scrie o funcție retry(times, block) care execută block și, dacă aruncă o excepție, îl reîncearcă de cel mult times ori, iar la final aruncă ultima eroare.

Răspuns scurt: O funcție generică fun <T> retry(times: Int, block: () -> T): T care rulează block într-un repeat cu try/catch, returnează la primul succes și, după ultima încercare eșuată, aruncă excepția păstrată.

O implementare simplă și corectă:

KOTLIN
fun <T> retry(times: Int, block: () -> T): T {
    require(times >= 1) { "times trebuie să fie cel puțin 1" }
    var lastError: Exception? = null
    repeat(times) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            lastError = e
            println("Încercarea ${attempt + 1} a eșuat: ${e.message}")
        }
    }
    throw checkNotNull(lastError)
}

val data = retry(3) { fetchFromServer() }

Detalii de discutat:

  • Funcția e generică, deci întoarce tipul produs de block, fără cast-uri.
  • return block() din interiorul lui repeat iese direct din retry. E posibil pentru că repeat este o funcție inline, deci lambda nu devine un obiect separat și un non-local return e permis.
  • Prinzi Exception, nu Throwable, ca să nu înghiți erori grave precum OutOfMemoryError.
  • checkNotNull documentează invarianta: după bucla completă, sigur am avut o eroare.

Pentru cod real ai mai multe îmbunătățiri:

  • o pauză între încercări, eventual crescătoare (exponential backoff);
  • un predicat care decide ce erori merită reîncercate: o eroare de rețea da, o eroare de validare nu;
  • o variantă suspend pentru coroutines, cu delay în loc de Thread.sleep și cu propagarea lui CancellationException, care nu trebuie prinsă și reîncercată.

Dacă intervievatorul cere, poți marca funcția inline ca să permiți și return non-local din block.

Ce urmărește intervievatorul: Este o problemă tipică de live coding care verifică generice, funcții de ordin superior și tratarea erorilor. Candidații slabi uită de ultima excepție sau prind Throwable.

29 Mid

Ce afișează cele două apeluri și de ce sunt diferite?

KOTLIN
fun findFirstNegative(nums: List<Int>) {
    nums.forEach {
        if (it < 0) {
            println("Găsit: $it")
            return
        }
        println("Verific $it")
    }
    println("Gata")
}

fun processAll(nums: List<Int>) {
    nums.forEach {
        if (it < 0) return@forEach
        println("Procesez $it")
    }
    println("Gata")
}

findFirstNegative(listOf(1, -2, 3))
processAll(listOf(1, -2, 3))

Răspuns scurt: Primul afișează Verific 1, Găsit: -2 și nu ajunge la „Gata”. Al doilea afișează Procesez 1, Procesez 3, Gata. Un return simplu iese din funcția exterioară, iar return@forEach iese doar din iterația curentă a lambda-ului.

În lambda-urile trimise funcțiilor inline, cum sunt forEach, map sau filter, un return fără etichetă este non-local return: iese din funcția care conține lambda. De aceea findFirstNegative se oprește la -2 și nu mai afișează nimic altceva.

return@forEach este un return cu etichetă: iese doar din lambda, pentru elementul curent, iar forEach continuă cu următorul. E echivalentul lui continue dintr-o buclă for.

Pentru o lambda trimisă unei funcții care nu e inline, un return simplu nu compilează, pentru că lambda poate rula mai târziu, când funcția exterioară s-a terminat deja.

Variante echivalente, uneori mai clare:

KOTLIN
for (n in nums) {
    if (n < 0) continue
    println("Procesez $n")
}

nums.forEach(fun(n) {          // funcție anonimă: return iese doar din ea
    if (n < 0) return
    println("Procesez $n")
})

val firstNegative = nums.firstOrNull { it < 0 }

Nu există break pentru forEach. Dacă vrei să te oprești la prima potrivire, folosești o buclă for, firstOrNull, takeWhile sau un return non-local, după cum ai nevoie.

Regula de lizibilitate: când ai nevoie de continue sau break, bucla for e de obicei mai ușor de citit decât forEach cu etichete.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii lui return în lambda, o sursă frecventă de bug-uri subtile. Mulți candidați cred că return din forEach funcționează ca continue.

Eroarea, în practică:'return' is prohibited here'break' and 'continue' only inside loops

30 Mid

Ce afișează codul de mai jos? Ce returnează fiecare scope function?

KOTLIN
val list = mutableListOf(1, 2).also { it.add(3) }
val added = mutableListOf(1, 2).let { it.add(3) }
val length = StringBuilder().apply { append("ab") }.run { append("c"); length }

println(list)
println(added)
println(length)

Răspuns scurt: Afișează [1, 2, 3], true și 3. also și apply întorc obiectul pe care au fost apelate, iar let și run întorc rezultatul lambda-ului: add dă Boolean, iar ultima expresie din run este length.

Cele cinci scope functions diferă pe două axe: cum accesezi obiectul în lambda și ce întoarce apelul.

  • let: obiectul e it, întoarce rezultatul lambda-ului.
  • run: obiectul e this, întoarce rezultatul lambda-ului.
  • with(obj): la fel ca run, dar obiectul e argument, nu receptor.
  • apply: obiectul e this, întoarce obiectul.
  • also: obiectul e it, întoarce obiectul.

În exemplu:

  • also { it.add(3) } întoarce lista modificată, deci [1, 2, 3].
  • let { it.add(3) } întoarce ce întoarce add, adică true. Variabila added este de tip Boolean, nu listă. E un bug clasic: cineva schimbă also cu let și tipul variabilei se schimbă pe tăcute.
  • apply { append("ab") } întoarce StringBuilder-ul, apoi run adaugă "c" și întoarce length, care este 3.

O altă capcană este this în apply și run. În interiorul lor, this e obiectul, iar un nume poate fi rezolvat atât ca membru al obiectului, cât și ca variabilă din exterior, ceea ce produce confuzii:

KOTLIN
class Request { var url = "" }
fun build(url: String) = Request().apply {
    this.url = url     // explicit: proprietatea primește parametrul
}

Regula de lizibilitate: nu înlănțui multe scope functions și nu le imbrica. Dacă trebuie să te gândești ce e it sau this, codul trebuie rescris cu variabile cu nume.

Ce urmărește intervievatorul: Verifică dacă știi exact valorile de return, nu doar „când se folosește fiecare”. Greșeala tipică este să crezi că let întoarce obiectul.

31 Mid

Ce afișează codul de mai jos? Ce spune asta despre felul în care funcționează extension functions?

KOTLIN
open class Shape
class Circle : Shape()

fun Shape.name() = "Shape"
fun Circle.name() = "Circle"

fun printName(s: Shape) = println(s.name())

fun main() {
    printName(Circle())
    println(Circle().name())
}

Răspuns scurt: Afișează Shape și apoi Circle. Extensiile se rezolvă static, după tipul declarat la compilare, nu după tipul real al obiectului. În printName, parametrul e declarat Shape, deci se alege Shape.name().

O funcție extensie nu modifică clasa. Compilatorul o transformă într-o funcție statică obișnuită care primește receptorul ca prim parametru:

KOTLIN
// fun Shape.name() devine, aproximativ:
// public static String name(Shape receiver)

Pentru că e o funcție statică, alegerea variantei se face la compilare, după tipul expresiei. În printName, s are tipul declarat Shape, deci se apelează Shape.name(), chiar dacă obiectul este un Circle. Nu există polimorfism (dispatch virtual) pentru extensii. În main, expresia Circle() are tipul Circle, deci se alege extensia mai specifică.

Alte consecințe ale acestui mecanism:

  • Membrii câștigă. Dacă clasa are deja o metodă cu aceeași semnătură, extensia este ignorată (compilatorul dă un avertisment).
  • Extensiile nu au acces la membrii private sau protected, pentru că din punctul de vedere al JVM-ului sunt cod din afara clasei.
  • Extensiile de proprietate nu pot avea câmp de stocare (backing field), deci se pot defini doar prin getter și setter.

Dacă ai nevoie de comportament diferit pe subclase, folosești o metodă open în clasă sau un when pe tipul real:

KOTLIN
fun Shape.describe() = when (this) {
    is Circle -> "cerc"
    else -> "formă"
}

Extensiile sunt potrivite pentru funcții utilitare care se citesc natural: String.isValidEmail() sau List<Order>.totalPrice().

Ce urmărește intervievatorul: Se verifică înțelegerea implementării extensiilor, nu doar a sintaxei. Răspunsul greșit tipic este Circle de două ori.

32 Mid

Ce rol au noinline și crossinline la parametrii unei funcții inline? De ce nu compilează primul exemplu fără crossinline?

KOTLIN
inline fun runLater(crossinline action: () -> Unit): Runnable =
    Runnable { action() }

val callbacks = mutableListOf<() -> Unit>()

inline fun register(first: () -> Unit, noinline second: () -> Unit) {
    first()
    callbacks.add(second)
}

Răspuns scurt: noinline spune că o anumită lambda nu se copiază în locul apelului, ci rămâne obiect, ca să poată fi stocată sau trimisă mai departe. crossinline permite inlinarea unei lambda folosite într-un alt context de execuție, dar interzice return non-local din ea.

O funcție inline copiază la compilare atât corpul ei, cât și corpul lambda-urilor primite, în locul apelului. De aceea lambda-urile ei pot face return non-local: codul lor ajunge fizic în funcția apelantă.

Problema apare când funcția nu apelează lambda direct, ci o folosește altfel:

  • Vrei să o păstrezi ca obiect (o pui într-o listă, o trimiți unei funcții non-inline). O lambda inlinată nu există ca obiect, deci compilatorul refuză. Marchezi parametrul noinline și acel parametru devine o lambda normală. În register, first e inlinat, iar second e stocat.
  • O apelezi dintr-un alt context, de exemplu din interiorul unui Runnable, al unui obiect anonim sau al altei lambda. Codul ar fi inlinat, dar un return non-local scris de apelant ar încerca să iasă dintr-o funcție care poate s-a terminat deja. crossinline permite inlinarea și interzice return non-local:
KOTLIN
fun main() {
    val r = runLater {
        println("rulat mai târziu")
        // return   // eroare: return non-local interzis în crossinline
    }
    r.run()
}

Fără crossinline, compilatorul dă eroare chiar la declararea lui runLater, pentru că nu poate garanta că lambda va fi folosită sigur.

Merită inline mai ales pentru funcții mici de ordin superior apelate des (ca filter sau measureTime), unde scapi de alocarea obiectului lambda. Pentru funcții mari, inlinarea crește dimensiunea codului fără câștig real.

Ce urmărește intervievatorul: Verifică înțelegerea detaliată a lui inline, utilă când scrii biblioteci sau utilitare. Mulți candidați cunosc inline doar în legătură cu reified.

Eroarea, în practică:Cannot inline 'block' here: add 'crossinline'Illegal usage of inline parameter: add 'noinline'

33 Senior

Ce costuri are folosirea intensivă a lambda-urilor în Kotlin pe JVM și cum le reduci acolo unde contează performanța?

Răspuns scurt: O lambda non-inline devine un obiect: fără captură poate fi refolosită, cu captură se alocă la fiecare creare, iar un var capturat e împachetat într-un obiect Ref. Reduci costul cu funcții inline, prin evitarea capturilor în buclele fierbinți și prin măsurare înainte de optimizare.

Pe JVM, o lambda trimisă unei funcții care nu e inline trebuie să existe ca obiect care implementează o interfață funcțională.

  • Fără captură, același obiect poate fi refolosit, deci costul e mic.
  • Cu captură de variabile sau de this, se creează un obiect nou la fiecare evaluare a expresiei lambda, ceea ce înseamnă presiune pe garbage collector într-o buclă care rulează des.
  • Un var capturat e mutat într-un obiect mutabil (Ref.IntRef, Ref.ObjectRef), iar fiecare acces trece prin el.
  • Tipurile generice ((T) -> R) lucrează cu obiecte, deci valorile Int sunt boxate la fiecare apel.

Din Kotlin 2.0, lambda-urile se compilează implicit prin invokedynamic (LambdaMetafactory), ca în Java, deci nu mai apare câte o clasă generată pentru fiecare lambda. Asta reduce mărimea bytecode-ului, dar alocarea pentru lambda-urile cu captură rămâne.

Cum reduci costurile:

KOTLIN
inline fun <T> measure(label: String, block: () -> T): T {
    val start = System.nanoTime()
    return block().also { println("$label: ${System.nanoTime() - start} ns") }
}
  • Marchezi inline funcțiile mici de ordin superior, apelate frecvent.
  • Pentru interfețe cu o singură metodă folosești fun interface, ca să ai conversie SAM și din Kotlin.
  • Folosești tablouri primitive (IntArray) și funcții specializate pentru date numerice mari.
  • Pentru lanțuri lungi pe colecții mari folosești Sequence, ca să eviți listele intermediare.

Mai important decât toate: măsori. Cu un profiler sau cu JMH vezi dacă alocările chiar contează. În majoritatea codului de aplicație, lizibilitatea lambda-urilor valorează mai mult decât câteva alocări.

Ce urmărește intervievatorul: La senior se verifică înțelegerea modelului de execuție, nu doar a sintaxei. Contează și echilibrul: un candidat bun nu propune micro-optimizări fără măsurare.

Clase, obiecte și moștenire

34 Junior

Explică diferența dintre name și age în clasa de mai jos și rolul constructorului secundar.

KOTLIN
class User(val name: String, age: Int) {
    val isAdult = age >= 18

    constructor(name: String) : this(name, 0)
}

Răspuns scurt: val name din constructorul primar declară și o proprietate a clasei. age e doar un parametru al constructorului, folosit la inițializare, dar care nu există după aceea. Constructorul secundar trebuie să delege la cel primar prin this(...).

Constructorul primar face parte din antetul clasei. Parametrii lui pot fi de două feluri:

  • cu val sau var: devin proprietăți, accesibile oriunde ca user.name;
  • fără val/var: sunt simpli parametri, vizibili doar în inițializatorii proprietăților și în blocurile init.

În exemplu, user.name funcționează, dar user.age nu compilează. age a fost folosit doar ca să calculeze isAdult. E o tehnică utilă când vrei să primești o valoare brută, dar să păstrezi doar ceva derivat din ea.

Constructorii secundari se declară cu constructor în corpul clasei și, dacă există un constructor primar, trebuie să delege la el (direct sau prin alt secundar) cu : this(...). Asta garantează că toată inițializarea trece printr-un singur loc.

În cod idiomatic, constructorii secundari sunt rari. Valorile implicite rezolvă de obicei același lucru, mai simplu:

KOTLIN
class User(val name: String, age: Int = 0) {
    val isAdult = age >= 18
}

User("Ana")          // age = 0
User("Dan", 30)

Constructorii secundari rămân utili când extinzi o clasă Java cu mai mulți constructori sau când ai nevoie de logică de conversie: constructor(dto: UserDto) : this(dto.name, dto.age ?: 0). Pentru a crea obiecte în moduri foarte diferite, o funcție factory în companion object e adesea mai clară.

Ce urmărește intervievatorul: Verifică înțelegerea constructorului primar, specific Kotlin. Greșeala tipică e să crezi că orice parametru al constructorului devine proprietate.

Eroarea, în practică:Primary constructor call expectedData class must only have val/var parameters

35 Junior

În ce ordine se afișează mesajele?

KOTLIN
fun log(s: String): String { println(s); return s }

class Demo(val x: Int) {
    val a = log("a = $x")
    init { log("init 1") }
    val b = log("b")
    init { log("init 2") }

    constructor() : this(0) {
        log("secundar")
    }
}

fun main() { Demo() }

Răspuns scurt: Afișează a = 0, init 1, b, init 2, secundar. Inițializatorii de proprietăți și blocurile init rulează în ordinea în care apar în clasă, ca parte a constructorului primar, iar corpul constructorului secundar rulează la final.

Kotlin adună într-un singur constructor primar, în ordinea textului din clasă, toate inițializatorii de proprietăți și blocurile init. Când apelezi Demo():

1. Se apelează constructorul secundar, care deleagă imediat la this(0). 2. Rulează constructorul primar: x primește 0, apoi, de sus în jos, a, primul init, b, al doilea init. 3. Abia după ce constructorul primar s-a terminat rulează corpul constructorului secundar.

Ordinea contează pentru că un inițializator poate folosi doar ce a fost inițializat deasupra lui. Dacă primul bloc init ar folosi b, ar vedea valoarea implicită a JVM-ului: null pentru obiecte sau 0 pentru numere. Pentru o proprietate String nenulabilă, asta poate produce un NullPointerException. Compilatorul prinde unele cazuri directe, dar nu pe cele indirecte, prin apeluri de funcții.

Ordinea în moștenire: întâi se inițializează complet clasa de bază (inițializatorii și blocurile init ale ei), apoi cele ale subclasei. De aceea e periculos să apelezi metode open din constructorul sau din init-ul clasei de bază: subclasa nu și-a inițializat încă proprietățile.

Recomandări practice: pune blocurile init după proprietățile pe care le folosesc, de preferință unul singur, și ține în ele doar validări (require) și inițializări simple.

Ce urmărește intervievatorul: Se verifică înțelegerea ciclului de inițializare, care explică bug-uri cu valori null neașteptate. Mulți candidați cred că toate blocurile init rulează înaintea proprietăților.

36 Junior

De ce nu compilează clasa Puppy? Ce înseamnă că în Kotlin clasele și metodele sunt final implicit?

KOTLIN
open class Animal {
    open fun sound() = "..."
    fun name() = "animal"
}

class Dog : Animal() {
    override fun sound() = "Ham"
}

class Puppy : Dog()

Răspuns scurt: Dog nu e marcată open, deci e final și nu poate fi extinsă. În Kotlin, clasele și metodele sunt închise implicit, iar moștenirea și suprascrierea trebuie permise explicit cu open.

Java permite implicit extinderea oricărei clase și suprascrierea oricărei metode, cu excepția celor marcate final. Kotlin face invers: totul e final până când autorul spune altceva.

  • O clasă se poate extinde doar dacă e open, abstract sau sealed.
  • O metodă sau proprietate se poate suprascrie doar dacă e open sau abstract.
  • Suprascrierea se marchează obligatoriu cu override. Nu poți suprascrie din greșeală, iar o greșeală de semnătură dă eroare de compilare.
  • Un membru override este implicit și el open. Dacă vrei să oprești lanțul, scrii final override fun sound().

În exemplu, name() nu poate fi suprascrisă în Dog, iar Puppy nu poate extinde Dog. Corectura:

KOTLIN
open class Dog : Animal() {
    override fun sound() = "Ham"
}
class Puppy : Dog() {
    override fun sound() = "Hămăit mic"
}

Motivul alegerii: o clasă proiectată pentru moștenire are nevoie de documentație și de grijă (ce metode pot fi suprascrise fără să strice invariantele). Majoritatea claselor nu sunt proiectate așa, iar final implicit previne problema „clasei de bază fragile”.

Consecință practică: framework-uri ca Spring sau Hibernate creează subclase proxy și au nevoie de clase deschise. Pentru ele se folosesc pluginurile de compilator kotlin-spring și kotlin-jpa (bazate pe all-open și no-arg), care deschid automat clasele adnotate.

Ce urmărește intervievatorul: Verifică o diferență de filozofie față de Java, cu impact real în proiecte. Candidații care nu știu de all-open au probleme la primul proiect Spring în Kotlin.

Eroarea, în practică:This type is final, so it cannot be extendedhides member of supertype, needs 'override'

37 Junior

Care este diferența dintre o clasă abstractă și o interfață în Kotlin? Ce poate conține fiecare?

Răspuns scurt: O interfață poate avea metode cu implementare și proprietăți abstracte sau calculate, dar nu poate păstra stare și nu are constructor. O clasă abstractă poate avea stare, constructor și membri protected, dar o clasă poate extinde o singură clasă și implementa oricâte interfețe.

Ambele definesc contracte care nu pot fi instanțiate direct, dar sunt potrivite pentru lucruri diferite.

Interfața descrie o capacitate:

KOTLIN
interface Named {
    val name: String                        // abstractă, o implementează clasa
    val displayName: String get() = name.uppercase()   // calculată, fără câmp
    fun greet() = "Salut, $displayName"     // implementare implicită
}

O interfață nu poate avea backing field (câmp de stocare), deci nu poți scrie val count = 0 în ea. Nu are constructor, iar o clasă poate implementa mai multe interfețe.

Clasa abstractă este o bază parțial implementată pentru o familie de clase:

KOTLIN
abstract class Account(val owner: String) {
    protected var balance: Long = 0
    abstract fun fee(): Long
    fun withdraw(amount: Long) {
        require(amount + fee() <= balance) { "Fonduri insuficiente" }
        balance -= amount + fee()
    }
}

class StudentAccount(owner: String) : Account(owner) {
    override fun fee() = 0L
}

Ea are constructor, stare, membri protected și poate impune un flux (metoda withdraw apelează metoda abstractă fee, ca în pattern-ul Template Method).

Cum alegi: implicit pornești cu o interfață, pentru că e mai flexibilă și se testează ușor cu implementări false. Treci la clasă abstractă când implementările chiar împart stare și logică. Membrii unei clase abstracte sunt open doar dacă sunt abstract sau marcați explicit.

Ce urmărește intervievatorul: Este o întrebare clasică OOP, iar la Kotlin se verifică detaliul că interfețele nu au stare. Greșeala tipică este să spui că interfețele nu pot avea cod deloc.

Eroarea, în practică:Class is not abstract and does not implementCannot create an instance of an abstract class

38 Junior

Ce modificatori de vizibilitate are Kotlin și prin ce diferă de Java? Ce înseamnă internal și private pentru o funcție de nivel superior?

Răspuns scurt: Kotlin are public (implicit), private, protected și internal. internal înseamnă vizibil în tot modulul, protected nu include pachetul ca în Java, iar private pe o declarație de nivel superior înseamnă vizibil doar în fișierul respectiv. Nu există package-private.

Modificatorii, pe scurt:

  • public: implicit. Vizibil oriunde. În Java implicitul este package-private.
  • private: într-o clasă, vizibil doar în acea clasă. Pentru o funcție, proprietate sau clasă de nivel superior (scrisă direct în fișier), vizibil doar în acel fișier.
  • protected: vizibil în clasă și în subclase. Spre deosebire de Java, nu include alte clase din același pachet. Nu se poate folosi pentru declarații de nivel superior.
  • internal: vizibil în tot modulul. Un modul este o unitate compilată împreună: un modul Gradle, un proiect Maven sau un set de surse.
KOTLIN
// fișierul PriceUtils.kt
private fun round2(x: Double) = Math.round(x * 100) / 100.0   // doar în acest fișier

internal class TaxCalculator {                                  // doar în modul
    fun vat(price: Double) = round2(price * 0.21)
}

internal este util în proiecte cu mai multe module: îți ascunzi implementarea față de alte module, dar o folosești liber în interior. Pe JVM, membrii internal devin publici în bytecode, cu nume modificate, așa că din Java pot fi accesați, chiar dacă nu e recomandat.

Bune practici: expui doar ce e necesar. Constructorii pot avea și ei modificatori (class Token private constructor(...)), iar o proprietate poate avea setter mai restrictiv decât getterul: var count = 0; private set. Pentru biblioteci, modul explicit API (explicitApi() în Gradle) cere ca fiecare declarație publică să aibă modificatorul scris explicit.

Ce urmărește intervievatorul: Se verifică cunoașterea exactă a regulilor, mai ales a lui internal și a diferenței la protected. Mulți candidați cred că Kotlin are package-private.

Eroarea, în practică:Cannot access: it is privateCannot weaken access privilege

39 Junior

Ce se întâmplă când rulezi Product().price = 10.0? Unde e bug-ul și cum îl corectezi?

KOTLIN
class Product {
    var price: Double = 0.0
        set(value) {
            require(value >= 0) { "Preț negativ" }
            price = value
        }
}

Răspuns scurt: Apare StackOverflowError. În setter, price = value apelează din nou setterul, la infinit. Corect este field = value, unde field este câmpul de stocare (backing field) al proprietății.

În Kotlin, o proprietate nu este doar un câmp. Este o pereche de accesori (getter și, pentru var, setter), plus, eventual, un câmp ascuns în care se păstrează valoarea. Orice scriere price = ..., inclusiv din interiorul clasei, trece prin setter.

În interiorul accesorilor, identificatorul field se referă la câmpul de stocare, ocolind accesorul. Varianta corectă:

KOTLIN
class Product {
    var price: Double = 0.0
        set(value) {
            require(value >= 0) { "Preț negativ" }
            field = value
        }

    val isFree: Boolean
        get() = price == 0.0          // proprietate calculată, fără câmp

    var stock: Int = 0
        private set                   // citire publică, scriere doar din clasă

    fun restock(n: Int) { stock += n }
}

Câmpul de stocare există doar dacă proprietatea îl folosește: dacă are inițializator sau dacă accesorii folosesc field. isFree nu are câmp, valoarea se calculează la fiecare citire.

Când alegi o proprietate calculată și când o funcție? Proprietatea e potrivită pentru operații ieftine, fără efecte secundare, care întorc același rezultat dacă starea nu s-a schimbat. Pentru calcule costisitoare sau operații cu efecte (citire din rețea, din fișier), o funcție semnalează corect costul.

Din Java, proprietatea se vede ca getPrice() și setPrice(double), deci validarea din setter se aplică și apelurilor din Java.

Ce urmărește intervievatorul: Verifică dacă înțelegi că proprietățile sunt accesori, nu câmpuri. Bug-ul cu recursivitatea apare des la candidații veniți din Java.

Eroarea, în practică:java.lang.StackOverflowErrorInitializer prohibited: no backing field

40 Junior

Cum declari un enum class cu proprietăți și metode? Ce face entries și cum transformi în siguranță un text în constantă de enum?

Răspuns scurt: Constantele primesc argumente prin constructorul enum-ului, iar după ultima constantă pui ; și membrii clasei. entries (din Kotlin 1.9) dă lista tuturor constantelor. Pentru conversie sigură folosești entries.find { it.name == text } în loc de valueOf, care aruncă excepție.

Un enum class definește un set fix de instanțe. Fiecare constantă e un obiect, așa că enum-ul poate avea proprietăți, metode și poate implementa interfețe:

KOTLIN
enum class OrderStatus(val label: String, val isFinal: Boolean) {
    NEW("Nouă", false),
    SHIPPED("Expediată", false),
    DELIVERED("Livrată", true),
    CANCELLED("Anulată", true);

    fun canCancel() = !isFinal
}

fun parseStatus(text: String): OrderStatus? =
    OrderStatus.entries.find { it.name.equals(text, ignoreCase = true) }

fun main() {
    println(OrderStatus.SHIPPED.label)              // Expediată
    println(OrderStatus.entries.filter { it.isFinal })
    println(OrderStatus.valueOf("NEW").ordinal)     // 0
    println(parseStatus("livrat"))                  // null
}

Detalii utile:

  • entries returnează o listă imutabilă, creată o singură dată. Vechea funcție values() alocă un tablou nou la fiecare apel, de aceea entries este recomandat din Kotlin 1.9.
  • valueOf("X") aruncă IllegalArgumentException dacă numele nu există, deci pentru date venite din exterior folosești varianta cu find. Pentru cod generic, versiunile recente oferă enumEntries<T>(), folosit în funcții inline cu reified.
  • ordinal este poziția în declarație. Nu-l salva în baza de date: dacă cineva adaugă o constantă la mijloc, toate valorile se decalează. Salvezi name sau un cod explicit.
  • Un when pe un enum folosit ca expresie trebuie să trateze toate constantele, iar compilatorul îți arată ce ai uitat când adaugi o constantă nouă.

Ce urmărește intervievatorul: Se verifică stăpânirea enum-urilor dincolo de liste de constante. Riscul cu ordinal salvat în baza de date este un detaliu pe care candidații buni îl menționează.

Eroarea, în practică:IllegalArgumentException: No enum constant

41 Mid

Ce afișează codul de mai jos? Ce capcane ale data class ilustrează?

KOTLIN
data class Order(val id: Int, val items: MutableList<String>) {
    var note: String = ""
}

fun main() {
    val a = Order(1, mutableListOf("carte"))
    a.note = "urgent"
    val b = a.copy()
    b.items.add("pix")
    println(a.items)
    println(b.note)
    println(a == b)
}

Răspuns scurt: Afișează [carte, pix], un rând gol și true. copy face copie superficială, deci listele sunt comune. Proprietatea note, declarată în corpul clasei, nu intră în copy, equals, hashCode sau toString.

O data class generează equals, hashCode, toString, copy și componentN doar pe baza proprietăților din constructorul primar. Asta explică cele trei rezultate.

1. copy e superficial (shallow). Se creează un Order nou, dar referința items e copiată, nu lista. a și b împart aceeași MutableList, deci modificarea prin b se vede și în a. 2. Proprietățile din corp sunt ignorate. copy apelează constructorul primar, iar note primește valoarea inițială "". Informația „urgent” se pierde pe tăcute. 3. equals compară doar id și items. Sunt egale (aceeași listă), deci a == b este true, deși note diferă.

Versiunea mai sigură:

KOTLIN
data class Order(
    val id: Int,
    val items: List<String>,
    val note: String = ""
)

val b = a.copy(items = a.items + "pix")   // listă nouă, a rămâne neschimbat

Alte capcane:

  • O data class cu proprietăți var folosită ca cheie într-un HashMap sau element într-un HashSet devine „pierdută” dacă o modifici după inserare, pentru că hashCode se schimbă.
  • O data class nu poate fi open, abstract sau inner. Poate extinde însă o clasă sau o interfață sealed, ceea ce e foarte comun.
  • toString include toate proprietățile, deci și parole sau tokenuri, care ajung ușor în loguri. Suprascrii toString sau ții datele sensibile în afara clasei.

Ce urmărește intervievatorul: Verifică înțelegerea exactă a codului generat. Candidații slabi cred că copy face o copie completă și că toate proprietățile intră în equals.

42 Mid

Care e diferența dintre o clasă imbricată (nested) și una inner în Kotlin? De ce poate o clasă inner să producă un memory leak?

Răspuns scurt: O clasă declarată în altă clasă este implicit nested: nu are referință la instanța exterioară, ca o clasă static din Java. Una inner ține o referință la obiectul exterior, deci îl ține în viață cât trăiește ea.

În Java, o clasă interioară fără static ține automat o referință la instanța exterioară. Kotlin a inversat implicitul:

KOTLIN
class Outer(val name: String) {
    class Nested {
        fun hello() = "nested"          // nu poate accesa name
    }

    inner class Inner {
        fun hello() = "inner din $name" // are acces la Outer
        fun outerRef() = this@Outer     // referință explicită la exterior
    }
}

fun main() {
    println(Outer.Nested().hello())
    println(Outer("A").Inner().hello())
}
  • Nested se creează fără instanță exterioară: Outer.Nested(). Folosești asta pentru clase ajutătoare care țin logic de clasa exterioară, de exemplu un Builder sau un tip de rezultat.
  • Inner se creează pornind de la o instanță: outer.Inner(). Are acces la membrii acesteia, inclusiv privați, și folosește this@Outer când există conflict de nume.

Memory leak: un obiect inner păstrează referința la obiectul exterior. Dacă obiectul inner ajunge într-un loc cu viață lungă (un registru static de listeneri, un cache, un thread în fundal), obiectul exterior nu poate fi eliberat de garbage collector, chiar dacă nu mai e folosit. Pe Android, exemplul clasic este o clasă interioară ținută de un thread, care ține în viață un ecran distrus.

Același lucru se întâmplă cu obiectele anonime (object : Listener { ... }) și cu lambda-urile care folosesc membrii clasei: capturează implicit this. Implicitul nested din Kotlin face cazul periculos vizibil prin cuvântul inner.

Ce urmărește intervievatorul: Verifică o diferență subtilă față de Java, cu impact asupra memoriei. Greșeala tipică e să crezi că, la fel ca în Java, o clasă imbricată vede automat membrii instanței exterioare.

Eroarea, în practică:Outer class of non-inner class used as receiver

43 Mid

Ce afișează codul și de ce? Cum corectezi clasa fără să o faci data class?

KOTLIN
class Point(val x: Int, val y: Int)

fun main() {
    val set = hashSetOf(Point(1, 2), Point(1, 2))
    println(set.size)
    println(Point(1, 2) == Point(1, 2))
}

Răspuns scurt: Afișează 2 și false. Clasa moștenește equals și hashCode de la Any, care compară identitatea obiectelor. Suprascrii amândouă metodele, pe baza lui x și y, respectând contractul dintre ele.

Orice clasă Kotlin extinde Any, care are implementări implicite pentru equals (identitate, ca ===) și hashCode (derivat din identitate). Două obiecte create separat sunt, așadar, diferite. HashSet le pune pe amândouă, iar == (care apelează equals) dă false.

Corectura:

KOTLIN
class Point(val x: Int, val y: Int) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is Point) return false
        return x == other.x && y == other.y
    }

    override fun hashCode(): Int = 31 * x + y

    override fun toString() = "Point($x, $y)"
}

Contractul dintre cele două metode:

  • dacă a == b, atunci a.hashCode() == b.hashCode();
  • invers nu e obligatoriu: două obiecte diferite pot avea același hash (coliziune);
  • equals trebuie să fie reflexiv, simetric, tranzitiv și consecvent, iar x.equals(null) trebuie să dea false.

Dacă suprascrii doar equals, HashSet și HashMap caută mai întâi după hash, deci găsesc altă „găleată” și nu ajung să compare cu equals. Rezultatul e duplicat sau căutări eșuate.

other !is Point face și smart cast, deci other.x merge fără cast. Dacă clasa e open, verificarea cu is poate încălca simetria între o clasă și subclasa ei; o variantă e compararea claselor exacte cu other::class != this::class.

Pentru clase care sunt doar purtătoare de date, data class le generează pe toate corect. Le scrii de mână când vrei ca doar unele câmpuri să conteze, de exemplu doar id-ul unei entități.

Ce urmărește intervievatorul: Verifică înțelegerea contractului equals/hashCode, o sursă clasică de bug-uri cu colecții. Răspunsul slab este „suprascriu doar equals”.

44 Mid

Clasa Duck de mai jos nu compilează fără metoda move suprascrisă. De ce? Cum apelezi implementările din ambele interfețe?

KOTLIN
interface Flyer { fun move() = "zbor" }
interface Swimmer { fun move() = "înot" }

class Duck : Flyer, Swimmer {
    override fun move() = super<Flyer>.move() + " și " + super<Swimmer>.move()
}

Răspuns scurt: Ambele interfețe oferă o implementare pentru aceeași metodă, deci compilatorul nu poate alege una. Clasa e obligată să o suprascrie, iar în interior poate apela fiecare variantă cu super<Interfață>.metodă(). Rezultatul este „zbor și înot”.

Este problema clasică a „diamantului” la moștenirea multiplă de comportament. O clasă poate implementa oricâte interfețe, iar interfețele pot avea implementări implicite. Când două interfețe definesc aceeași semnătură, apare un conflict pe care Kotlin nu îl rezolvă automat: refuză să compileze și îți cere o decizie explicită.

Sintaxa super<Flyer>.move() alege implementarea dintr-un anumit supertip. O poți folosi și pentru a combina comportamentele, ca în exemplu, sau pentru a delega la una dintre ele:

KOTLIN
class Penguin : Flyer, Swimmer {
    override fun move() = super<Swimmer>.move()   // nu zboară
}

Aceeași regulă se aplică și unei clase care extinde o clasă de bază cu o metodă open și implementează o interfață cu aceeași metodă: super<Animal>.move() față de super<Swimmer>.move().

Conflictul apare și când doar una dintre interfețe are implementare, iar cealaltă declară metoda abstractă. În acest caz poți apela super<Flyer>.move(), dar nu și varianta abstractă.

Cum eviți situația în design: interfețele mici, cu responsabilități clare (Interface Segregation), au rar metode cu același nume. Dacă două interfețe au o metodă comună cu sens real, ea poate fi mutată într-o interfață de bază comună. Implementările implicite din interfețe sunt bune pentru comportament auxiliar, nu pentru logică principală pe care o moștenesc toate clasele.

Ce urmărește intervievatorul: Verifică înțelegerea moștenirii multiple de comportament prin interfețe. Puțini candidați cunosc sintaxa super<T>.

Eroarea, în practică:Class is not abstract and does not implementMust override: inherits multiple interface methods

45 Senior

Ce este o value class și când o folosești? În ce situații obiectul este totuși alocat (boxat)?

KOTLIN
@JvmInline
value class UserId(val value: Long)

@JvmInline
value class Email(val value: String) {
    init { require("@" in value) { "Email invalid: $value" } }
}

fun sendWelcome(id: UserId, email: Email) { /* ... */ }

Răspuns scurt: O value class împachetează o singură valoare într-un tip distinct, verificat de compilator, iar la rulare folosește direct valoarea, fără obiect. Obiectul se alocă totuși când e folosit ca tip nulabil, ca parametru generic, ca interfață sau în colecții.

Problema rezolvată: o funcție fun transfer(from: Long, to: Long, amount: Long) se poate apela cu argumentele inversate, iar compilatorul nu observă nimic. Cu tipuri dedicate (AccountId, Money), greșeala devine eroare de compilare. O clasă obișnuită ar adăuga însă o alocare pentru fiecare valoare.

O value class (@JvmInline value class) are exact o proprietate în constructorul primar. Compilatorul folosește la rulare valoarea interioară, adică un long sau un String, iar tipul există doar la compilare. Poate avea metode, proprietăți calculate, blocuri init pentru validare și poate implementa interfețe.

Când apare totuși boxing-ul (crearea obiectului împachetat):

  • ca tip nulabil: UserId? (cu excepția unor cazuri cu valori interioare care nu sunt primitive);
  • ca argument generic: List<UserId>, Map<UserId, User>, T;
  • când e tratată ca interfața pe care o implementează sau ca Any.

Alte detalii senior:

  • Funcțiile care primesc value classes au nume modificate în bytecode (de exemplu sendWelcome-abc123), ca să evite conflicte de semnătură. Din Java sunt greu de apelat. @JvmName sau o funcție simplă ajutătoare rezolvă asta.
  • Egalitatea se face pe valoarea interioară; === nu are sens și e interzis.
  • Bibliotecile de serializare și de baze de date trebuie să știe de ele (kotlinx.serialization le suportă).

Folosește-le pentru identificatori, unități de măsură, sume de bani sau stringuri validate, unde confuzia între valori de același tip primitiv e un risc real.

Ce urmărește intervievatorul: La senior se verifică modelarea sigură a domeniului și înțelegerea costurilor la rulare. Candidații slabi cred că value classes nu sunt niciodată alocate.

Eroarea, în practică:Value classes without '@JvmInline' not supportedValue class must have exactly one parameter

46 Senior

Vrei să numeri câte elemente au fost adăugate într-un set. De ce e fragilă varianta prin moștenire de la HashSet și cum o rescrii prin compoziție?

Răspuns scurt: Moștenirea depinde de detaliile interne ale clasei de bază: dacă addAll apelează intern add, numeri de două ori. Compoziția, mai ales cu delegarea by, depinde doar de interfață, deci nu se strică atunci când se schimbă implementarea clasei de bază.

Varianta prin moștenire, inspirată de exemplul clasic din „Effective Java”:

KOTLIN
class CountingSet<T> : HashSet<T>() {
    var added = 0
    override fun add(element: T): Boolean { added++; return super.add(element) }
    override fun addAll(elements: Collection<T>): Boolean {
        added += elements.size
        return super.addAll(elements)
    }
}

Dacă implementarea lui HashSet.addAll apelează add pentru fiecare element (cum face AbstractCollection), fiecare element e numărat de două ori. Corectitudinea clasei tale depinde de un detaliu intern pe care nu-l controlezi și care se poate schimba între versiuni. Aceasta este problema clasei de bază fragile.

Varianta prin compoziție, cu delegarea de interfață din Kotlin:

KOTLIN
class CountingSet<T>(
    private val inner: MutableSet<T> = HashSet()
) : MutableSet<T> by inner {
    var added = 0
        private set

    override fun add(element: T): Boolean {
        added++
        return inner.add(element)
    }

    override fun addAll(elements: Collection<T>): Boolean {
        added += elements.size
        return inner.addAll(elements)
    }
}

by inner generează automat toate celelalte metode ale interfeței, care delegă la inner. Când inner.addAll apelează intern add, apelează metoda lui HashSet, nu pe a ta, deci nu mai apare dublarea.

Kotlin încurajează această direcție: clasele sunt final implicit, delegarea are sintaxă proprie, iar ierarhiile închise se modelează cu sealed. Moștenirea rămâne potrivită pentru ierarhii proiectate explicit pentru extindere, cu metode open puține și documentate. Ca decizie de arhitectură: moștenirea exprimă „este un”, compoziția exprimă „folosește un”, iar a doua se testează și se schimbă mai ușor.

Ce urmărește intervievatorul: La senior se verifică judecata de design, nu doar sintaxa. Un răspuns bun explică de ce moștenirea e fragilă și arată soluția idiomatică din Kotlin.

Colecții și secvențe

47 Junior

Ce afișează codul? Este b o listă imutabilă?

KOTLIN
val a = mutableListOf(1, 2)
val b: List<Int> = a
a.add(3)
println(b)
println((b as MutableList<Int>).add(4))
println(a)

Răspuns scurt: Afișează [1, 2, 3], true și [1, 2, 3, 4]. List este doar o interfață read-only: nu ai metode de modificare prin ea, dar obiectul de dedesubt poate fi modificat de cine are o referință mutabilă sau de cine face cast.

Kotlin separă interfețele de colecții în read-only (List, Set, Map) și mutabile (MutableList, MutableSet, MutableMap). Distincția există la compilare: o variabilă de tip List nu are add. Pe JVM, ambele interfețe sunt implementate de aceleași clase Java, de exemplu ArrayList.

În exemplu, a și b arată spre același ArrayList. Ce adaugi prin a se vede prin b. Cast-ul la MutableList reușește, pentru că obiectul real chiar e mutabil, deci „read-only” nu înseamnă „imutabil”.

De ce contează: dacă o clasă expune o colecție internă ca List, apelanții nu o pot modifica direct, dar o văd schimbându-se în timp ce o parcurg. Dacă o parcurgi într-un thread și altcineva o modifică, poți primi ConcurrentModificationException.

Cum obții o garanție reală:

KOTLIN
class Cart {
    private val _items = mutableListOf<String>()
    val items: List<String> get() = _items.toList()   // copie la fiecare citire
    fun add(item: String) { _items += item }
}
  • toList() face o copie. E simplu și sigur, dar costă la colecții mari.
  • Biblioteca kotlinx.collections.immutable oferă PersistentList și ImmutableList, cu garanții reale și copiere eficientă.
  • listOf(...) creează o listă pe care nu o poți modifica nici cu cast (aruncă UnsupportedOperationException la add), dar tipul nu garantează asta în general.

Pe scurt: tipul read-only e o promisiune despre ce poți face prin acea referință, nu despre obiect.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre read-only și imutabil. Majoritatea candidaților spun că List e imutabilă.

Eroarea, în practică:Unresolved reference 'add' on 'List'UnsupportedOperationException

48 Junior

Ce afișează codul și care e diferența dintre Array, IntArray și List?

KOTLIN
val a = arrayOf(1, 2, 3)
val b = arrayOf(1, 2, 3)
println(a == b)
println(a.contentEquals(b))
println(listOf(1, 2, 3) == listOf(1, 2, 3))
println(a.contentToString())

Răspuns scurt: Afișează false, true, true, [1, 2, 3]. Tablourile compară referințe cu ==, deci ai nevoie de contentEquals, în timp ce listele compară conținutul. println(a) simplu ar afișa ceva de tipul [Ljava.lang.Integer;@1b6d3586.

Array în Kotlin corespunde unui tablou Java: dimensiune fixă, elemente modificabile prin index, fără equals sau toString utile. == pe tablouri compară identitatea, de aceea primul rezultat e false. Pentru conținut folosești contentEquals, iar pentru afișare contentToString() sau joinToString().

Array<Int> și IntArray sunt diferite:

  • Array<Int> (din arrayOf(1, 2, 3)) este Integer[] în Java: fiecare element e un obiect boxat.
  • IntArray (din intArrayOf(1, 2, 3) sau IntArray(10)) este int[]: valori primitive, mai puțină memorie, acces mai rapid.

Pentru calcule numerice pe volume mari sau pentru interoperabilitate cu API-uri Java care cer int[], folosești tablourile primitive.

List este o colecție cu equals, hashCode și toString care compară și afișează conținutul. List<Int> boxează și ea elementele. List are o mulțime de operații funcționale, deși multe există și pe tablouri.

KOTLIN
val scores = IntArray(5) { it * 10 }    // [0, 10, 20, 30, 40]
scores[0] = 100
val asList = scores.toList()            // List<Int>
val back = asList.toIntArray()

În codul de aplicație preferi List, care e mai expresivă și are semantică de egalitate corectă. Tablourile apar la vararg, la interoperabilitate cu Java și în codul optimizat pentru performanță. O data class cu un câmp Array are equals bazat pe identitatea tabloului, iar compilatorul te avertizează exact din acest motiv.

Ce urmărește intervievatorul: Se verifică diferența dintre tablouri și liste, inclusiv boxing-ul. Greșeala tipică este compararea tablourilor cu == în teste.

Eroarea, în practică:Array literals outside of annotations

49 Junior

Ce tip are stock["mere"] în codul de mai jos? Explică diferența dintre accesul cu [], getValue și getOrPut.

KOTLIN
val stock = mutableMapOf("mere" to 10, "pere" to 0)
val m = stock["mere"]
val k = stock["kiwi"] ?: 0
val p = stock.getOrPut("prune") { 5 }
for ((fruit, qty) in stock) println("$fruit: $qty")

Răspuns scurt: stock["mere"] are tipul Int?, pentru că cheia poate lipsi. getValue întoarce Int și aruncă NoSuchElementException dacă cheia lipsește, iar getOrPut întoarce valoarea existentă sau calculează, inserează și întoarce una nouă.

Operatorul map[key] apelează get, care întoarce null când cheia nu există. De aceea tipul este mereu nulabil, chiar dacă valorile din map nu sunt null. Compilatorul te obligă să tratezi cazul cheii lipsă.

Variante pentru citire:

  • map[key] ?: implicit: cel mai des folosită.
  • map.getOrDefault(key, implicit): similară, vine din Java.
  • map.getOrElse(key) { calcul }: calculează valoarea implicită doar când e nevoie.
  • map.getValue(key): când cheia trebuie să existe; aruncă excepție cu mesaj clar, mai bine decât map[key]!!.

Pentru scriere:

KOTLIN
stock["mere"] = 9                               // set
stock["mere"] = (stock["mere"] ?: 0) + 1        // incrementare sigură
val list = groups.getOrPut("admin") { mutableListOf() }
list += "Ana"                                   // lista din map e modificată
stock.remove("pere")

getOrPut este idiomatic pentru cache-uri și grupări manuale: valoarea se calculează și se inserează doar la prima cerere.

Parcurgerea cu for ((fruit, qty) in stock) folosește destructurarea pe Map.Entry. Ordinea e cea de inserare, pentru că mutableMapOf creează un LinkedHashMap. Dacă ai nevoie de ordinea cheilor, folosești toSortedMap(). mapOf primește perechi create cu funcția infix to, care creează un Pair. Pentru map-uri mari construite în bucle, buildMap { put(...) } evită perechile temporare.

Ce urmărește intervievatorul: Verifică lucrul corect cu Map și cu nulabilitatea rezultatelor. Răspunsul slab folosește map[key]!! peste tot.

Eroarea, în practică:Key is missing in the map

50 Junior

Sortează o listă de studenți descrescător după notă, iar la note egale alfabetic după nume. Care e diferența dintre sort() și sorted()?

KOTLIN
data class Student(val name: String, val grade: Double)

val students = listOf(
    Student("Maria", 9.5), Student("Andrei", 8.0),
    Student("Bianca", 9.5), Student("Dan", 7.25)
)

Răspuns scurt: Folosești students.sortedWith(compareByDescending<Student> { it.grade }.thenBy { it.name }). sorted() și variantele ei întorc o listă nouă, iar sort() sortează pe loc și există doar pe MutableList și pe tablouri.

Pentru un singur criteriu ai funcții directe: sortedBy { it.name }, sortedByDescending { it.grade }. Pentru mai multe criterii construiești un Comparator:

KOTLIN
val ranking = students.sortedWith(
    compareByDescending<Student> { it.grade }.thenBy { it.name }
)
ranking.forEach { println("${it.name}: ${it.grade}") }
// Bianca: 9.5
// Maria: 9.5
// Andrei: 8.0
// Dan: 7.25

// variantă cu mai multe chei în același sens:
val byGradeThenName = students.sortedWith(compareBy({ it.grade }, { it.name }))

Tipul generic explicit <Student> la compareByDescending e necesar pentru că, fără el, compilatorul nu poate deduce tipul din lambda înainte de thenBy.

sorted față de sort:

  • sorted(), sortedBy, sortedWith lucrează pe orice Iterable și întorc o listă nouă. Originalul rămâne neschimbat.
  • sort(), sortBy, sortWith modifică pe loc o MutableList sau un tablou și întorc Unit. O greșeală frecventă este val s = list.sort(), unde s devine Unit.

Sortarea din Kotlin pe JVM este stabilă: elementele egale după criteriu își păstrează ordinea inițială. De aceea poți sorta și în doi pași (întâi după nume, apoi după notă), deși un singur comparator e mai clar.

Pentru tipuri proprii cu ordine naturală, implementezi Comparable<T>, iar apoi sorted() și maxOrNull() funcționează direct. Pentru texte în română cu diacritice, ordinea simplă după cod Unicode poate fi greșită; un java.text.Collator pentru limba română dă o ordine corectă.

Ce urmărește intervievatorul: Este o sarcină tipică de live coding. Se verifică dacă știi să construiești comparatori compuși și diferența dintre sortarea pe loc și cea cu copie.

Eroarea, în practică:sorted() is inapplicable: receiver type mismatch

51 Junior

Ce afișează fiecare linie?

KOTLIN
val nums = listOf(1, 2, 3, 4)
println(nums.reduce { acc, n -> acc * n })
println(nums.fold(10) { acc, n -> acc + n })
println(nums.fold("") { acc, n -> acc + n })
println(emptyList<Int>().fold(0) { acc, n -> acc + n })
println(emptyList<Int>().reduce { acc, n -> acc + n })

Răspuns scurt: Afișează 24, 20, 1234, 0, iar ultima linie aruncă UnsupportedOperationException. reduce pornește de la primul element și eșuează pe listă goală, iar fold pornește de la o valoare inițială, care poate avea alt tip decât elementele.

Ambele funcții „pliază” o colecție într-o singură valoare, aplicând o operație între un acumulator și fiecare element.

  • reduce folosește primul element ca acumulator inițial, deci rezultatul are același tip ca elementele (sau un supertip). Pe o colecție goală nu are de unde porni și aruncă excepție. Varianta sigură este reduceOrNull.
  • fold primește explicit valoarea inițială. Funcționează pe colecții goale (întoarce valoarea inițială) și permite alt tip de rezultat, ca în exemplul cu String.

Calculele din exemplu: 1 * 2 * 3 * 4 = 24; 10 + 1 + 2 + 3 + 4 = 20; "" + 1 + 2 + 3 + 4 = "1234".

Pentru operațiile uzuale există funcții dedicate, mai clare:

KOTLIN
nums.sum()                         // 10
orders.sumOf { it.price * it.qty } // suma unei proprietăți
nums.maxOrNull()
nums.average()                     // Double, NaN pentru listă goală
nums.runningFold(0) { acc, n -> acc + n }   // [0, 1, 3, 6, 10], sume parțiale

fold e potrivit când construiești ceva mai complex, de exemplu un obiect de statistici:

KOTLIN
data class Stats(val count: Int = 0, val total: Int = 0)
val stats = nums.fold(Stats()) { s, n -> Stats(s.count + 1, s.total + n) }

Concatenarea de stringuri cu fold creează câte un String nou la fiecare pas. Pentru liste mari, joinToString("") sau buildString sunt mai eficiente.

Ce urmărește intervievatorul: Verifică dacă știi comportamentul pe colecții goale, o sursă frecventă de crash-uri în producție. Candidații slabi folosesc reduce fără să se gândească la acest caz.

Eroarea, în practică:Empty collection can't be reduced

52 Junior

Scrie o funcție care primește un text și întoarce de câte ori apare fiecare cuvânt, ignorând majusculele și semnele de punctuație, apoi afișează primele 3 cuvinte ca frecvență.

Răspuns scurt: Transformi textul în litere mici, îl împarți după orice caracter care nu e literă sau cifră, elimini bucățile goale și numeri cu groupingBy { it }.eachCount(). Pentru top 3 sortezi intrările descrescător după valoare și iei primele trei.

O soluție idiomatică:

KOTLIN
fun wordFrequency(text: String): Map<String, Int> =
    text.lowercase()
        .split(Regex("[^\\p{L}\\p{N}]+"))
        .filter { it.isNotEmpty() }
        .groupingBy { it }
        .eachCount()

fun main() {
    val text = "Kotlin e concis. Kotlin e sigur, iar codul Kotlin e clar!"
    val freq = wordFrequency(text)
    freq.entries
        .sortedByDescending { it.value }
        .take(3)
        .forEach { (word, count) -> println("$word: $count") }
}
// kotlin: 3
// e: 3
// concis: 1

Explicații:

  • \p{L} înseamnă orice literă Unicode, deci diacriticele românești rămân în cuvinte. Un [^a-z] simplu ar tăia „ș” sau „ț”.
  • split poate produce un string gol la început, dacă textul începe cu punctuație, de aceea filtrăm.
  • groupingBy { it }.eachCount() numără direct, fără să construiască liste intermediare. groupBy { it }.mapValues { it.value.size } dă același rezultat, dar creează o listă pentru fiecare cuvânt.
  • Sortarea e stabilă, deci la egalitate rămâne ordinea primei apariții.

Discuție de complexitate: numărarea este O(n) în lungimea textului, sortarea este O(k log k) pentru k cuvinte distincte. Pentru top k dintr-un vocabular foarte mare poți folosi un PriorityQueue de dimensiune k.

La interviu merită să întrebi ce înseamnă „cuvânt” (numere, cratime, apostrofuri) și dacă trebuie tratate egalitățile, înainte de a scrie codul.

Ce urmărește intervievatorul: Este un exercițiu clasic de live coding care verifică fluența cu operațiile pe colecții. Contează și întrebările de clarificare, nu doar codul.

53 Junior

Ce afișează fiecare linie?

KOTLIN
val empty = emptyList<Int>()
println(empty.all { it > 100 })
println(empty.any { it > 100 })
println(empty.none())

val (even, odd) = listOf(1, 2, 3, 4, 5).partition { it % 2 == 0 }
println(even)
println(odd)
println(listOf(3, 7, 9).find { it > 5 })
println(listOf(3, 7, 9).count { it > 5 })

Răspuns scurt: Afișează true, false, true, [2, 4], [1, 3, 5], 7, 2. all e adevărat pe o listă goală pentru că nu există niciun contraexemplu, partition împarte lista în două după predicat, iar find întoarce primul element potrivit sau null.

Funcțiile de căutare și verificare:

  • any { }: există cel puțin un element care respectă condiția? Pe listă goală: false.
  • all { }: toate elementele respectă condiția? Pe listă goală: true. Este „adevăr vid”, ca în logica matematică: afirmația „toți studenții din sala goală au nota 10” nu are niciun contraexemplu.
  • none { }: niciun element nu respectă condiția. Fără argument, none() întreabă dacă lista e goală.
  • find { } (alias firstOrNull { }): primul element potrivit, sau null.
  • count { }: câte elemente se potrivesc.

Capcana cu all pe listă goală produce bug-uri reale:

KOTLIN
val canShip = order.items.all { it.inStock }   // true pentru o comandă fără produse!
val canShipSafe = order.items.isNotEmpty() && order.items.all { it.inStock }

partition întoarce un Pair<List<T>, List<T>>: primul conține elementele pentru care predicatul e adevărat, al doilea pe restul. Destructurarea val (even, odd) e naturală aici. Avantajul față de două filter-uri este o singură parcurgere.

Toate funcțiile de tip any, all, find se opresc la primul element care decide rezultatul, deci nu parcurg inutil restul colecției. count { } și partition parcurg mereu tot.

Pentru verificarea existenței unui element anume, x in list (adică contains) e mai clar decât any { it == x }.

Ce urmărește intervievatorul: Verifică funcțiile de bază și cazurile limită. Comportamentul lui all pe colecție goală prinde mulți candidați nepregătiți.

Eroarea, în practică:No element matching the predicate

54 Mid

Ce diferență e între associateBy, associateWith, associate și groupBy? Ce se întâmplă în codul de mai jos cu produsele care au același id?

KOTLIN
data class Product(val id: Int, val name: String, val price: Double)

val products = listOf(
    Product(1, "Carte", 30.0),
    Product(2, "Pix", 5.0),
    Product(1, "Caiet", 10.0)
)
val byId = products.associateBy { it.id }

Răspuns scurt: associateBy construiește un map cu cheia calculată și elementul ca valoare, associateWith cu elementul drept cheie, associate cu ambele calculate, iar groupBy pune toate elementele cu aceeași cheie într-o listă. La chei duplicate, associate* păstrează ultimul element, deci „Carte” se pierde.

Cele patru funcții transformă o listă într-un Map, dar diferă prin cheie și valoare:

KOTLIN
products.associateBy { it.id }
// {1=Product(1, Caiet, 10.0), 2=Product(2, Pix, 5.0)}

products.associateWith { it.price > 20 }
// {Product(1, Carte, 30.0)=true, Product(2, Pix, 5.0)=false, Product(1, Caiet, 10.0)=false}

products.associate { it.name to it.price }
// {Carte=30.0, Pix=5.0, Caiet=10.0}

products.groupBy { it.id }
// {1=[Product(1, Carte, ...), Product(1, Caiet, ...)], 2=[Product(2, Pix, ...)]}

products.groupBy({ it.id }, { it.name })
// {1=[Carte, Caiet], 2=[Pix]}

Capcana principală: funcțiile associate* presupun chei unice. La duplicat, ultima valoare o suprascrie pe cea veche, fără avertisment. Dacă datele vin dintr-un API sau dintr-o bază de date și cheia nu e garantat unică, ai pierdere silențioasă de date.

Ce faci:

  • dacă duplicatele sunt posibile și valide, folosești groupBy;
  • dacă duplicatele înseamnă date corupte, le detectezi explicit:
KOTLIN
val duplicates = products.groupingBy { it.id }.eachCount().filterValues { it > 1 }
require(duplicates.isEmpty()) { "ID-uri duplicate: ${duplicates.keys}" }

associateBy e foarte util pentru căutări repetate: transformi o listă într-un map o singură dată, apoi fiecare căutare e O(1), în loc de list.find { } în buclă, care e O(n) la fiecare pas. Map-ul rezultat păstrează ordinea de inserare.

Ce urmărește intervievatorul: Se verifică alegerea funcției potrivite și atenția la chei duplicate. Candidații de nivel mediu ar trebui să observe pierderea silențioasă de date.

55 Mid

Ce afișează fiecare linie?

KOTLIN
val n = listOf(1, 2, 3, 4, 5)
println(n.chunked(2))
println(n.windowed(3))
println(n.windowed(2) { it.sum() })
println(n.zip(listOf("a", "b")))
println(n.zipWithNext { a, b -> b - a })
println(listOf(listOf(1, 2), listOf(3)).flatten())
println(listOf("ab", "cd").flatMap { it.toList() })

Răspuns scurt: Afișează [[1, 2], [3, 4], [5]], [[1, 2, 3], [2, 3, 4], [3, 4, 5]], [3, 5, 7, 9], [(1, a), (2, b)], [1, 1, 1, 1], [1, 2, 3] și [a, b, c, d].

Aceste funcții apar des în problemele de interviu și înlocuiesc bucle cu indici, unde e ușor să greșești limitele.

  • chunked(n) împarte lista în bucăți consecutive de n elemente. Ultima bucată poate fi mai mică. E util pentru procesare pe loturi, de exemplu trimiterea a câte 100 de înregistrări către un API.
  • windowed(size) creează ferestre glisante care se suprapun. Implicit, ferestrele incomplete de la final sunt omise; cu partialWindows = true sunt incluse. Parametrul step controlează cât avansează fereastra. Varianta cu lambda transformă fiecare fereastră direct, fără să păstreze listele.
  • zip combină două colecții element cu element și se oprește la cea mai scurtă. Rezultatul e o listă de Pair, sau ce întoarce lambda, dacă dai una.
  • zipWithNext combină fiecare element cu următorul, util pentru diferențe între valori consecutive.
  • flatten aplatizează o listă de liste.
  • flatMap transformă fiecare element într-o colecție și le unește.

Exemplu practic, media mobilă pe 3 zile:

KOTLIN
val sales = listOf(10.0, 12.0, 9.0, 15.0, 11.0)
val moving = sales.windowed(3) { it.average() }
// [10.33.., 12.0, 11.66..]

Atenție la performanță: windowed fără lambda creează o listă pentru fiecare fereastră. Pentru volume mari, varianta cu lambda sau o fereastră glisantă manuală cu sumă actualizată incremental (O(n) în loc de O(n·k)) este mai eficientă.

Ce urmărește intervievatorul: Verifică vocabularul de operații pe colecții, des folosit la live coding. Candidații care le cunosc scriu soluții mai scurte și cu mai puține greșeli de indici.

Eroarea, în practică:size 0 must be greater than zero (chunked)

56 Mid

Ce afișează codul cu secvență? Ce s-ar afișa dacă ai șterge .asSequence()?

KOTLIN
val result = listOf(1, 2, 3, 4)
    .asSequence()
    .map { println("map $it"); it * 2 }
    .filter { println("filter $it"); it > 4 }
    .first()
println(result)

Răspuns scurt: Cu secvență: map 1, filter 2, map 2, filter 4, map 3, filter 6, apoi 6. Fără secvență se execută întâi map pe toate cele patru elemente, apoi filter pe toate cele patru rezultate, și abia apoi first() dă 6.

Operațiile pe colecții (List, Set) sunt eager: fiecare pas parcurge toată colecția și creează o listă intermediară. Fără asSequence(), ordinea este:

map 1, map 2, map 3, map 4
filter 2, filter 4, filter 6, filter 8
6

O Sequence este lazy (leneșă): operațiile intermediare nu fac nimic până la o operație terminală (first, toList, sum, count). Apoi fiecare element trece prin tot lanțul, unul câte unul, iar first() oprește procesarea la primul rezultat valid. Elementul 4 nu mai e procesat deloc.

Când merită secvențele:

  • lanțuri cu mai mulți pași pe colecții mari, unde listele intermediare costă memorie;
  • operații care se pot opri devreme: first, take, any, find;
  • surse infinite sau generate: generateSequence(1) { it * 2 }, sequence { yield(...) }.

Când nu merită:

  • colecții mici, unde costul suplimentar al obiectelor de secvență depășește câștigul;
  • un singur pas (list.map { });
  • operații care au oricum nevoie de toate elementele, ca sorted. Aceasta e o operație „cu stare” care consumă toată secvența înainte de a continua.

O secvență se poate parcurge de obicei de mai multe ori, dar fiecare parcurgere reia calculul de la zero. Dacă lambda are efecte secundare (log, apel de rețea), ele se repetă. Spre deosebire de java.util.stream, secvențele Kotlin nu au procesare paralelă.

Ce urmărește intervievatorul: Verifică înțelegerea evaluării leneșe. Candidații care răspund corect la ordinea afișărilor au înțeles cu adevărat diferența, nu doar definiția.

57 Senior

Codul de mai jos e lent pe liste cu sute de mii de elemente. Ce probleme vezi și cum le optimizezi?

KOTLIN
fun report(orders: List<Order>, vipIds: List<Long>): List<String> {
    var result = listOf<String>()
    for (o in orders) {
        if (o.customerId in vipIds) {
            result = result + "${o.id}: ${o.total}"
        }
    }
    return result
}

Răspuns scurt: in vipIds pe o listă e O(m) pentru fiecare comandă, deci total O(n·m), iar result + ... copiază toată lista la fiecare adăugare, adică O(n²). Transformi vipIds într-un HashSet și construiești rezultatul cu buildList sau cu filter și map.

Două probleme de complexitate, ambele ascunse de sintaxa curată:

1. o.customerId in vipIds apelează List.contains, care parcurge lista. Pentru n comenzi și m clienți VIP ai O(n·m) comparații. Un HashSet are contains în O(1) în medie. 2. result = result + element creează de fiecare dată o listă nouă cu toate elementele vechi plus unul. Pentru k rezultate, asta înseamnă O(k²) copieri și multă presiune pe garbage collector.

Versiunea optimizată:

KOTLIN
fun report(orders: List<Order>, vipIds: Collection<Long>): List<String> {
    val vip = vipIds.toHashSet()
    return orders
        .filter { it.customerId in vip }
        .map { "${it.id}: ${it.total}" }
}

Complexitatea devine O(n + m). Dacă lanțul are mai mulți pași, asSequence() sau mapNotNull evită o listă intermediară.

Alte tipare de urmărit în code review:

  • list.removeAt(0) într-o buclă este O(n) la fiecare apel. Pentru cozi folosești ArrayDeque.
  • sortedBy sau distinct apelate în interiorul unei bucle, în loc de o singură dată înainte.
  • list.indexOf sau list.find repetate. Construiești un map cu associateBy o singură dată.
  • Liste de Int sau Double foarte mari, unde boxing-ul contează; IntArray sau DoubleArray reduc memoria.
  • count() pe o secvență doar ca să verifici dacă e goală, în loc de any().

Pași de lucru: măsori înainte (profiler, JMH pentru microbenchmark-uri), cauți complexitatea algoritmică înainte de micro-optimizări și adaugi un test cu date mari care să prindă regresia.

Ce urmărește intervievatorul: La senior se verifică ochiul pentru complexitate ascunsă în cod idiomatic. Candidații slabi propun micro-optimizări și ratează problema O(n²).

Generice și varianță

Exersează capitolul cu exerciții reale: Curs Kotlin pentru începători →
58 Junior

Scrie o clasă generică Box<T> cu o metodă map care transformă conținutul, și o funcție extensie generică secondOrNull() pentru liste.

Răspuns scurt: class Box<T>(val value: T) cu fun <R> map(transform: (T) -> R) = Box(transform(value)), iar fun <T> List<T>.secondOrNull(): T? = if (size >= 2) this[1] else null. Tipurile se deduc din argumente la apel.

Genericele permit cod care funcționează pentru orice tip, păstrând verificarea la compilare. Parametrul de tip se declară între paranteze unghiulare, după numele clasei sau înaintea numelui funcției.

KOTLIN
class Box<T>(val value: T) {
    fun <R> map(transform: (T) -> R): Box<R> = Box(transform(value))
    override fun toString() = "Box($value)"
}

fun <T> List<T>.secondOrNull(): T? = if (size >= 2) this[1] else null

fun main() {
    val a = Box(5)                       // Box<Int>, T dedus din argument
    val b = a.map { "nr. $it" }          // Box<String>
    println(b)                           // Box(nr. 5)
    println(listOf("x", "y").secondOrNull())   // y
    println(emptyList<Int>().secondOrNull())   // null
}

Ce merită subliniat:

  • map are propriul parametru de tip R, independent de T-ul clasei. Așa funcționează și List.map din biblioteca standard.
  • Inferența scutește de scrierea tipurilor: Box(5) devine Box<Int>. Când nu există din ce deduce, scrii tipul explicit: emptyList<Int>().
  • Rezultatul lui secondOrNull este T?. Dacă T e deja nulabil (List<String?>), un null primit poate însemna fie „nu există al doilea element”, fie „al doilea element e null”. Pentru majoritatea cazurilor e acceptabil, dar e bine să știi ambiguitatea.

Fără generice ai avea fie câte o clasă pentru fiecare tip, fie Any și cast-uri peste tot, cu riscul unui ClassCastException la rulare. Genericele mută această verificare la compilare.

Ce urmărește intervievatorul: Verifică dacă poți scrie cod generic simplu de la zero. Greșeala tipică este folosirea lui Any și a cast-urilor în loc de un parametru de tip.

59 Junior

Scrie o funcție generică maxOf3(a, b, c) care întoarce maximul a trei valori de orice tip care poate fi comparat. Ce înseamnă T : Comparable<T> și când ai nevoie de where?

Răspuns scurt: fun <T : Comparable<T>> maxOf3(a: T, b: T, c: T): T, care folosește > sau maxOf. T : Comparable<T> este o constrângere: acceptă doar tipuri comparabile cu ele însele. where se folosește când T trebuie să respecte mai multe constrângeri simultan.

Fără constrângere, compilatorul nu știe nimic despre T, deci nu poți compara două valori de tip T. O limită superioară (upper bound) spune ce operații are tipul:

KOTLIN
fun <T : Comparable<T>> maxOf3(a: T, b: T, c: T): T {
    var max = a
    if (b > max) max = b
    if (c > max) max = c
    return max
}

println(maxOf3(3, 9, 4))                // 9
println(maxOf3("pere", "mere", "prune")) // prune
// maxOf3(listOf(1), listOf(2), listOf(3))  // eroare: List nu e Comparable

Operatorul > pe tipuri Comparable se traduce în compareTo(...) > 0.

Pentru mai multe constrângeri folosești where:

KOTLIN
fun <T> sortedNames(items: List<T>): List<String>
        where T : Comparable<T>, T : CharSequence =
    items.sorted().map { it.toString() }

Aici T trebuie să fie și comparabil, și secvență de caractere.

Alte situații frecvente:

  • <T : Any> exclude tipurile nulabile;
  • <T : Number> permite toDouble() pe valori;
  • <E : Enum<E>> pentru funcții care lucrează cu orice enum.

O constrângere bine aleasă face API-ul sigur: un apel greșit e respins la compilare cu un mesaj clar, nu la rulare. În același timp, o constrângere prea strictă reduce inutil reutilizarea. Biblioteca standard are deja maxOf(a, b, c) și maxOf(a, vararg others), iar la interviu e bine să menționezi asta după ce arăți că știi să scrii funcția.

Ce urmărește intervievatorul: Verifică dacă știi să constrângi parametrii de tip ca să poți folosi operații specifice. Candidații slabi încearcă cast la Comparable în corpul funcției.

Eroarea, în practică:Type argument is not within its boundssorted() is inapplicable: receiver type mismatch

60 Junior

Implementează o stivă generică Stack<T> cu operațiile push, pop, peek și isEmpty, apoi folosește-o ca să verifici dacă parantezele dintr-un text sunt echilibrate.

Răspuns scurt: Clasa folosește intern un ArrayDeque<T>: push adaugă la final, pop și peek întorc ultimul element sau null. Verificarea parantezelor pune pe stivă fiecare deschidere și, la fiecare închidere, verifică dacă vârful stivei e perechea corectă.

KOTLIN
class Stack<T> {
    private val items = ArrayDeque<T>()

    fun push(item: T) = items.addLast(item)
    fun pop(): T? = items.removeLastOrNull()
    fun peek(): T? = items.lastOrNull()
    fun isEmpty() = items.isEmpty()
    val size: Int get() = items.size
}

fun isBalanced(text: String): Boolean {
    val pairs = mapOf(')' to '(', ']' to '[', '}' to '{')
    val stack = Stack<Char>()
    for (ch in text) {
        when (ch) {
            '(', '[', '{' -> stack.push(ch)
            ')', ']', '}' -> if (stack.pop() != pairs[ch]) return false
        }
    }
    return stack.isEmpty()
}

fun main() {
    println(isBalanced("a(b[c]{d})"))   // true
    println(isBalanced("(]"))           // false
    println(isBalanced("(("))           // false
}

Decizii de discutat:

  • ArrayDeque din biblioteca standard Kotlin are operații O(1) la ambele capete. O MutableList ar merge la fel, dar ArrayDeque arată clar intenția.
  • pop întoarce T? în loc să arunce excepție. Alternativa este fun pop(): T = items.removeLast(), care aruncă NoSuchElementException pe stivă goală. Alegerea depinde de API: pentru o structură de interviu, varianta nulabilă simplifică algoritmul, pentru că o închidere fără deschidere dă null, diferit de orice paranteză.
  • Lista internă e private, deci invariantele stivei nu pot fi ocolite din afară.
  • La final verifici că stiva e goală, ca să prinzi deschiderile rămase fără pereche.

Complexitate: O(n) timp, O(n) memorie în cel mai rău caz.

Ce urmărește intervievatorul: Combină genericele cu o problemă clasică de algoritmi. Se verifică încapsularea și tratarea cazurilor limită, cum ar fi închiderea fără deschidere.

Eroarea, în practică:NoSuchElementException: ArrayDeque is empty

61 Mid

De ce compilează primul apel, dar al doilea nu?

KOTLIN
fun printAll(items: List<Any>) = items.forEach { println(it) }
fun addNumber(items: MutableList<Any>) { items.add(42) }

val names: List<String> = listOf("Ana")
printAll(names)

val mutableNames: MutableList<String> = mutableListOf("Ana")
addNumber(mutableNames)

Răspuns scurt: List este declarată List<out E>, adică covariantă: o List<String> e acceptată unde se cere List<Any>, pentru că doar citești din ea. MutableList<E> e invariantă: dacă ar fi permis, addNumber ar pune un Int într-o listă de String.

Varianța descrie relația dintre tipurile generice când tipurile lor argument sunt în relație de moștenire. String este subtip al lui Any. Este List<String> subtip al lui List<Any>?

  • Pentru List, da. Interfața e declarată interface List<out E>. Modificatorul out promite că E apare doar în poziții de ieșire (valori întoarse), nu ca parametru de intrare. O listă din care doar citești String-uri poate fi tratată în siguranță ca o listă din care citești Any.
  • Pentru MutableList<E>, nu. E apare și ca intrare (add(element: E)). Dacă al doilea apel ar compila, mutableNames ar conține un Int, iar codul care citește String-uri ar primi un ClassCastException mai târziu.

Comparația cu Java ajută:

JAVA
// Java: tablourile sunt covariante, deci verificarea se face la rulare
Object[] arr = new String[1];
arr[0] = 42;   // ArrayStoreException la rulare

În Kotlin, Array<T> este invariant, deci această greșeală e prinsă la compilare.

Dacă vrei ca addNumber să accepte liste de tipuri mai largi, schimbi semnătura: fun addNumber(items: MutableList<in Int>). Acum primește MutableList<Int>, MutableList<Number> sau MutableList<Any>, pentru că în toate se poate pune în siguranță un Int.

Regula de memorat: producătorii sunt out (doar dau valori), consumatorii sunt in (doar primesc valori), iar ce face ambele lucruri rămâne invariant.

Ce urmărește intervievatorul: Verifică înțelegerea de ce varianța există, nu doar a sintaxei in/out. Mulți candidați nu știu că List și MutableList diferă exact aici.

Eroarea, în practică:out projection prohibits the use of 'add'

62 Mid

Care e diferența dintre List<*>, List<Any?> și MutableList<*>? Ce poți face cu o variabilă de tip MutableList<*>?

Răspuns scurt: * (star projection) înseamnă „o listă de un tip anume, necunoscut”. Din MutableList<*> citești elemente ca Any?, dar nu poți adăuga nimic, pentru că tipul real nu e cunoscut. MutableList<Any?> acceptă orice element, dar nu primește o MutableList<String>.

Star projection se folosește când nu știi sau nu te interesează argumentul de tip, dar vrei să lucrezi sigur cu obiectul.

KOTLIN
fun printSize(list: MutableList<*>) {
    println(list.size)
    val first: Any? = list.firstOrNull()    // citirea dă Any?
    // list.add("x")                        // eroare: tipul real e necunoscut
    list.clear()                            // permis: nu depinde de tip
}

val strings = mutableListOf("a", "b")
printSize(strings)                          // OK

fun addAnything(list: MutableList<Any?>) { list.add(42) }
// addAnything(strings)                     // eroare: MutableList e invariantă

Diferențele:

  • MutableList<Any?> este o listă care chiar poate conține orice. Accepți doar liste create cu exact acest tip, din cauza invarianței.
  • **MutableList<*>** este o listă de un tip T necunoscut. Accepți orice MutableList, dar citești doar ca Any? și nu poți scrie valori, pentru că nu ai cum să garantezi că se potrivesc.
  • Pentru **List<*>**, care e covariantă, diferența față de List<Any?> e mică în practică: ambele acceptă orice listă și dau Any? la citire.

Unde apare star projection:

  • la verificări de tip, pentru că tipurile generice sunt șterse la rulare: if (x is List<*>) compilează, x is List<String> nu;
  • în funcții care lucrează cu structura, nu cu elementele: dimensiune, golire, afișare;
  • la reflecție: KClass<*>, Class<*>.

Echivalentul în Java este wildcard-ul ? din List<?>.

Ce urmărește intervievatorul: Verifică înțelegerea fină a proiecțiilor de tip. Candidații confundă des * cu Any? și nu pot explica de ce scrierea e interzisă.

Eroarea, în practică:One type argument expected for List

63 Mid

De ce nu compilează prima verificare? Ce este type erasure și cum îl ocolești?

KOTLIN
fun check(x: Any) {
    if (x is List<String>) println("listă de stringuri")
}

Răspuns scurt: Pe JVM, argumentele de tip generic sunt șterse la compilare (type erasure), deci la rulare există doar List, fără String. Poți verifica x is List<*> și elementele individual sau poți folosi o funcție inline cu parametru reified.

Java și Kotlin pe JVM implementează genericele prin ștergerea tipurilor: informația <String> e folosită de compilator pentru verificări, apoi dispare din bytecode. Un obiect ArrayList<String> și unul ArrayList<Int> au exact aceeași clasă la rulare. De aceea compilatorul refuză is List<String>: nu are cum să o verifice.

Variante care funcționează:

KOTLIN
fun check(x: Any) {
    if (x is List<*>) {
        val strings = x.filterIsInstance<String>()
        if (strings.size == x.size) println("toate elementele sunt String")
    }
}

Cast-ul nesigur compilează cu avertisment, dar problema apare mai târziu:

KOTLIN
@Suppress("UNCHECKED_CAST")
val list = listOf(1, 2) as List<String>   // reușește la rulare!
val s: String = list[0]                   // ClassCastException aici

Eroarea apare departe de cauză, unde codul folosește elementul, ceea ce o face greu de depanat.

Parametrii reified din funcțiile inline ocolesc ștergerea. Funcția e copiată la locul apelului, unde tipul concret e cunoscut:

KOTLIN
inline fun <reified T> Any.isListOf(): Boolean =
    this is List<*> && all { it is T }

println(listOf("a", "b").isListOf<String>())  // true

Bibliotecile ocolesc ștergerea și prin „tokeni de tip”: Gson folosește TypeToken, Jackson TypeReference, iar kotlinx.serialization generează serializatori la compilare. Toate păstrează informația pe care JVM-ul o pierde.

Ce urmărește intervievatorul: Verifică dacă înțelegi limitarea de platformă, nu doar că există reified. Răspunsul slab e „pun un cast și merge”.

Eroarea, în practică:Cannot check for instance of erased typeCannot use 'T' as reified type parameter

64 Senior

Explică semnătura de mai jos. De ce from e out și to e in? Cum se vede asta din Java?

KOTLIN
fun <T> copy(from: List<out T>, to: MutableList<in T>) {
    for (item in from) to.add(item)
}

val ints = listOf(1, 2, 3)
val numbers = mutableListOf<Number>(0.5)
copy(ints, numbers)

Răspuns scurt: Este varianță la locul folosirii (use-site variance): from e doar citit, deci acceptă liste de T sau subtipuri, iar to e doar scris, deci acceptă liste de T sau supertipuri. Din Java apare ca List<? extends T> și List<? super T>, adică regula PECS.

Kotlin are două feluri de varianță:

  • La declarare (declaration-site): interface List<out E>. Toate folosirile lui List sunt covariante.
  • La folosire (use-site, sau type projection): adaugi in sau out la un anumit parametru al unei funcții, pentru un tip care e invariant în declarația lui, cum e MutableList.

În exemplu, T este dedus Int:

  • from: List<out T> acceptă List<Int>. Pentru List modificatorul e redundant, dar ar conta dacă from ar fi MutableList<out T>: lista ar putea fi citită, iar add ar fi interzis pe acea referință.
  • to: MutableList<in T> acceptă MutableList<Number>, pentru că un Int poate fi pus într-o listă de Number. Citirea din to dă doar Any?.

Fără proiecții, semnătura fun <T> copy(from: MutableList<T>, to: MutableList<T>) ar cere ca ambele liste să aibă exact același tip, iar apelul de mai sus nu ar compila.

Echivalentul din Java este regula PECS (Producer Extends, Consumer Super): List<? extends T> pentru surse, List<? super T> pentru destinații.

Detalii de interoperabilitate:

  • Compilatorul Kotlin generează wildcard-uri în semnăturile vizibile din Java pentru parametrii cu tipuri covariante: un parametru List<Animal> devine List<? extends Animal> dacă Animal nu e clasă finală. Pentru tipurile de return, nu generează wildcard-uri, ca să nu le impună apelanților Java.
  • @JvmWildcard și @JvmSuppressWildcards controlează explicit acest comportament. Contează la framework-uri bazate pe reflecție, cum e Dagger, unde un wildcard neașteptat schimbă tipul cerut.

Ce urmărește intervievatorul: La senior se verifică stăpânirea completă a varianței și a efectelor ei în interoperabilitate. Puțini candidați știu de wildcard-urile generate automat.

Eroarea, în practică:out projection prohibits the use of 'add'

65 Senior

De ce nu compilează interfața de mai jos? Cum funcționează Collection<out E>.contains(element: E) în biblioteca standard, deși E apare acolo ca parametru de intrare?

KOTLIN
interface Producer<out T> {
    fun produce(): T
    fun accept(item: T)
}

Răspuns scurt: Un parametru out T nu poate apărea ca tip de parametru de intrare, pentru că ar permite scrierea unor valori de tip greșit. contains folosește @UnsafeVariance, care suspendă verificarea, deoarece funcția doar compară elementul și nu-l stochează.

Compilatorul verifică pozițiile în care apare un parametru de tip cu varianță:

  • out T poate apărea doar în poziții de ieșire: tipuri de return și proprietăți val;
  • in T poate apărea doar în poziții de intrare: parametri de funcții.

accept(item: T) pune un out T în poziție de intrare. Dacă ar fi permis, ai putea face:

KOTLIN
val strings: Producer<String> = ...
val anys: Producer<Any> = strings      // permis datorită covarianței
anys.accept(42)                        // un Int ajunge într-un Producer<String>

Soluțiile corecte sunt să separi interfața în producător și consumator sau să renunți la varianță.

@UnsafeVariance este o portiță: îi spui compilatorului „știu că încalc regula, dar folosirea e sigură”. Biblioteca standard o folosește în Collection<out E>:

KOTLIN
public interface Collection<out E> : Iterable<E> {
    public operator fun contains(element: @UnsafeVariance E): Boolean
}

E sigur pentru că contains doar compară elementul cu equals și nu-l stochează. Fără adnotare, List<String> nu ar mai putea fi covariantă și ai pierde List<String> folosită ca List<Any>.

Contravarianța apare natural la comparatori:

KOTLIN
val byHash: Comparator<Any> = compareBy { it.hashCode() }
val sorted = listOf("b", "a").sortedWith(byHash)   // Comparator<in T> acceptă Comparator<Any>

Membrii private sunt scutiți de verificarea varianței, pentru că nu pot fi folosiți din afară într-un mod nesigur. Folosește @UnsafeVariance rar și doar când poți demonstra că valoarea nu ajunge stocată sau întoarsă cu tip greșit.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a regulilor de varianță și a modului în care biblioteca standard le ocolește în siguranță. E o întrebare de diferențiere pentru roluri senior.

Eroarea, în practică:'out' type parameter occurs in 'in' position

Delegare, operatori și DSL-uri

66 Junior

Ce afișează codul de mai jos? Ce fac Delegates.observable și Delegates.vetoable?

KOTLIN
import kotlin.properties.Delegates

class Settings {
    var theme: String by Delegates.observable("light") { prop, old, new ->
        println("${prop.name}: $old -> $new")
    }
    var volume: Int by Delegates.vetoable(50) { _, _, new -> new in 0..100 }
}

fun main() {
    val s = Settings()
    s.theme = "dark"
    s.volume = 150
    s.volume = 80
    println(s.volume)
}

Răspuns scurt: Afișează theme: light -> dark și apoi 80. observable rulează un callback după fiecare schimbare, iar vetoable rulează o verificare înainte de schimbare și o respinge dacă rezultatul e false, deci 150 nu e acceptat.

Ambele sunt delegați de proprietate din biblioteca standard. Prin by, citirile și scrierile proprietății sunt transmise unui obiect care decide ce se întâmplă.

Delegates.observable(initial) { property, old, new -> }:

  • păstrează valoarea și o întoarce la citire;
  • după fiecare atribuire, apelează lambda cu proprietatea (un KProperty, de unde iei numele), valoarea veche și cea nouă;
  • callback-ul rulează și când valoarea nouă e egală cu cea veche.

Delegates.vetoable(initial) { property, old, new -> Boolean }:

  • apelează lambda înainte de schimbare;
  • dacă lambda întoarce false, valoarea rămâne cea veche, fără excepție.

În exemplu, volume = 150 e respins în tăcere, iar volume = 80 e acceptat.

Utilizări tipice: logarea schimbărilor, invalidarea unui cache când se schimbă o setare, notificarea interfeței. Atenție însă la vetoable: respingerea silențioasă poate ascunde bug-uri. Dacă o valoare invalidă e o greșeală a apelantului, un setter cu require e mai potrivit, pentru că semnalează imediat problema:

KOTLIN
var volume: Int = 50
    set(value) {
        require(value in 0..100) { "Volum invalid: $value" }
        field = value
    }

În aplicațiile cu interfață reactivă, starea observabilă se modelează de obicei cu StateFlow, care suportă mai mulți observatori și coroutines, nu cu observable. observable rămâne util pentru logică locală simplă.

Ce urmărește intervievatorul: Verifică cunoașterea delegaților standard și judecata de a alege între respingere silențioasă și eroare explicită. Candidații slabi nu știu ce primește lambda.

67 Junior

Definește o clasă Money pe care să o poți aduna cu +, înmulți cu un număr și compara cu <. Cum funcționează supraîncărcarea operatorilor în Kotlin?

Răspuns scurt: Declari funcții membre sau extensii marcate operator, cu nume fixe: plus pentru +, times pentru *, compareTo pentru < și >. Compilatorul traduce a + b în a.plus(b), deci operatorii sunt doar sintaxă peste funcții obișnuite.

Kotlin nu permite inventarea de operatori noi, dar permite să dai sens operatorilor existenți pentru tipurile tale, prin funcții cu nume convenționale:

KOTLIN
data class Money(val cents: Long) : Comparable<Money> {
    operator fun plus(other: Money) = Money(cents + other.cents)
    operator fun minus(other: Money) = Money(cents - other.cents)
    operator fun times(factor: Int) = Money(cents * factor)
    operator fun unaryMinus() = Money(-cents)
    override fun compareTo(other: Money) = cents.compareTo(other.cents)
    override fun toString() = "%d,%02d lei".format(cents / 100, cents % 100)
}

fun main() {
    val price = Money(1999)
    val total = price * 3 + Money(500)
    println(total)                   // 64,97 lei
    println(total > Money(5000))     // true
    var wallet = Money(10000)
    wallet -= total                  // folosește minus și reatribuie
}

Corespondențe uzuale:

  • + - * / % corespund lui plus, minus, times, div, rem;
  • a[i] și a[i] = v corespund lui get și set;
  • x in a corespunde lui a.contains(x);
  • a() corespunde lui invoke;
  • a..b corespunde lui rangeTo;
  • == corespunde lui equals, iar < și > lui compareTo.

compareTo vine aici din Comparable, deci e deja operator. += folosește plusAssign dacă există, altfel plus plus reatribuire, ceea ce cere un var.

Regula de design: operatorii au sens doar când semnificația e evidentă (bani, vectori, matrice, intervale de timp). user + group nu spune nimic și face codul greu de citit. Funcția infix to din mapOf("a" to 1) este un exemplu înrudit: o funcție obișnuită, marcată infix, apelată fără punct și paranteze.

Ce urmărește intervievatorul: Verifică dacă știi mecanismul convențiilor și ai judecată în folosirea lor. Mulți candidați nu știu că in și [] sunt tot operatori supraîncărcabili.

Eroarea, în practică:Unresolved reference 'minus' for operator '-''operator' modifier is required on 'fun plus...'

68 Junior

Cum funcționează destructurarea în Kotlin? Ce trebuie să aibă o clasă obișnuită ca să poți scrie val (start, end) = interval?

Răspuns scurt: Destructurarea apelează funcțiile component1(), component2() și așa mai departe, în ordine. data class și Pair le generează automat, iar pentru o clasă obișnuită le declari tu ca funcții operator.

Declarația val (a, b) = obj este tradusă de compilator în val a = obj.component1() și val b = obj.component2(). Destructurarea e pozițională: contează ordinea, nu numele variabilelor.

KOTLIN
data class User(val name: String, val age: Int)

class Interval(val start: Int, val end: Int) {
    operator fun component1() = start
    operator fun component2() = end
}

fun main() {
    val (name, age) = User("Ana", 30)
    val (start, end) = Interval(1, 10)
    val (_, onlyAge) = User("Dan", 25)          // _ sare peste o componentă

    val scores = mapOf("Ana" to 9, "Dan" to 7)
    for ((student, score) in scores) println("$student: $score")
    scores.forEach { (student, score) -> println(student + score) }

    for ((index, value) in listOf("a", "b").withIndex()) println("$index $value")
}

Locuri unde apare des: perechi (Pair, Triple), intrări de map, withIndex(), rezultatul lui partition și parametrii lambda. Atenție la sintaxă: în lambda, { (a, b) -> } destructurează un singur parametru, iar { a, b -> } înseamnă doi parametri.

Capcana principală: dacă cineva schimbă ordinea proprietăților într-o data class, de exemplu User(val age: Int, val name: String), codul val (name, age) = user compilează în continuare când tipurile se potrivesc. Dacă ambele ar fi String, valorile s-ar inversa în tăcere. De aceea destructurarea e potrivită pentru tipuri mici și stabile, nu pentru clase de domeniu cu multe câmpuri, unde accesul prin nume (user.name) e mai sigur.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului din spatele unei sintaxe folosite zilnic. Riscul la reordonarea proprietăților e un detaliu pe care îl menționează candidații atenți.

Eroarea, în practică:Destructuring requires 'component1()'

69 Mid

Ce moduri de sincronizare are by lazy și când alegi fiecare? Ce se întâmplă dacă inițializatorul aruncă o excepție?

Răspuns scurt: Implicit, lazy folosește SYNCHRONIZED: inițializatorul rulează o singură dată, protejat de un lock. PUBLICATION permite rulări concurente, dar păstrează primul rezultat, iar NONE nu are sincronizare. Dacă inițializatorul aruncă, valoarea nu e salvată și următorul acces încearcă din nou.

val x by lazy { ... } calculează valoarea la primul acces și o păstrează pentru următoarele. Parametrul opțional LazyThreadSafetyMode stabilește comportamentul în prezența mai multor thread-uri:

KOTLIN
val config: Config by lazy { loadConfig() }                        // SYNCHRONIZED
val parser by lazy(LazyThreadSafetyMode.PUBLICATION) { Parser() }
val formatter by lazy(LazyThreadSafetyMode.NONE) { createFormatter() }
  • SYNCHRONIZED (implicit): un singur thread rulează inițializatorul, iar celelalte așteaptă. Garanția e cea mai puternică, dar există un cost mic de sincronizare la primul acces. Și un risc: dacă inițializatorul așteaptă după un alt lock deținut de un thread care încearcă să citească aceeași proprietate, poți ajunge la deadlock.
  • PUBLICATION: mai multe thread-uri pot rula inițializatorul simultan, dar doar primul rezultat e păstrat și văzut de toți. Potrivit când calculul e ieftin și fără efecte secundare.
  • NONE: fără nicio protecție. Corect doar când proprietatea e accesată dintr-un singur thread, de exemplu doar de pe thread-ul principal al unei interfețe. Are cel mai mic cost.

La excepție, lazy nu memorează eroarea. Următorul acces rulează din nou inițializatorul. Comportamentul e util pentru erori temporare, dar poate produce reîncercări costisitoare repetate.

Alte detalii:

  • lazy merge doar cu val. Pentru var inițializat mai târziu există lateinit sau un var nulabil.
  • Lambda inițializatorului e păstrată până la primul acces, deci obiectele capturate rămân în memorie până atunci.
  • isInitialized() pe obiectul Lazy spune dacă valoarea a fost deja calculată, util la eliberarea resurselor.

Ce urmărește intervievatorul: Verifică dacă știi ce garanții oferă lazy în cod concurent. Majoritatea candidaților știu doar că e „inițializare leneșă”.

Eroarea, în practică:'Lazy' cannot serve as a delegate for var

70 Mid

Scrie un delegat de proprietate Trimmed care elimină automat spațiile de la începutul și sfârșitul oricărui text atribuit, și folosește-l într-o clasă Form.

Răspuns scurt: Implementezi interfața ReadWriteProperty<Any?, String>, cu getValue care întoarce valoarea păstrată și setValue care salvează value.trim(). Apoi declari var name by Trimmed() în clasă.

Un delegat de proprietate este orice obiect cu funcțiile getValue (și setValue pentru var), marcate operator. Interfețele ReadOnlyProperty și ReadWriteProperty din biblioteca standard dau semnăturile corecte:

KOTLIN
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

class Trimmed(initial: String = "") : ReadWriteProperty<Any?, String> {
    private var value = initial.trim()

    override fun getValue(thisRef: Any?, property: KProperty<*>): String = value

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        this.value = value.trim()
    }
}

class Form {
    var name by Trimmed()
    var email by Trimmed()
}

fun main() {
    val f = Form()
    f.name = "   Ana Pop  "
    println("[${f.name}]")    // [Ana Pop]
}

Ce trebuie să știi despre mecanism:

  • Pentru fiecare proprietate delegată, compilatorul creează un câmp ascuns care ține obiectul delegat, iar accesorii proprietății apelează getValue și setValue.
  • thisRef este obiectul care conține proprietatea (aici, Form), iar property dă acces la metadate, de exemplu property.name, util pentru validări cu mesaje clare sau pentru citirea din preferințe după nume.
  • Fiecare proprietate are propriul obiect delegat, deci name și email nu împart starea.

Variante utile din biblioteca standard: delegarea către un map, val name: String by map, folosită la configurații dinamice, și provideDelegate, care permite validări în momentul declarării proprietății.

Delegații personalizați sunt potriviți pentru comportamente repetate (normalizare, validare, citire din preferințe, logare). Pentru un singur caz izolat, un setter cu field e mai simplu.

Ce urmărește intervievatorul: Verifică dacă înțelegi delegarea de proprietăți suficient cât să scrii una. E un semn de stăpânire a limbajului peste nivelul de bază.

71 Mid

Ce înseamnă tipul HtmlBuilder.() -> Unit? Scrie un mic DSL care permite codul de mai jos și explică cum funcționează.

KOTLIN
val page = html {
    p("Salut")
    ul {
        li("unu")
        li("doi")
    }
}

Răspuns scurt: Este o lambda cu receiver: în interiorul ei, this este un HtmlBuilder, deci îi poți apela metodele direct, fără prefix. Funcția html creează builder-ul, rulează lambda pe el și întoarce rezultatul.

Un tip funcție cu receiver, T.() -> R, descrie o funcție care se execută „în contextul” unui obiect T. Este mecanismul din spatele lui apply, buildString și al DSL-urilor (limbaje specifice domeniului) din Gradle Kotlin DSL, Ktor sau Compose.

KOTLIN
class ListBuilder(private val sb: StringBuilder) {
    fun li(text: String) { sb.append("<li>").append(text).append("</li>") }
}

class HtmlBuilder {
    private val sb = StringBuilder()
    fun p(text: String) { sb.append("<p>").append(text).append("</p>") }
    fun ul(block: ListBuilder.() -> Unit) {
        sb.append("<ul>")
        ListBuilder(sb).block()
        sb.append("</ul>")
    }
    fun build() = sb.toString()
}

fun html(block: HtmlBuilder.() -> Unit): String =
    HtmlBuilder().apply(block).build()

fun main() {
    val page = html {
        p("Salut")
        ul { li("unu"); li("doi") }
    }
    println(page)   // <p>Salut</p><ul><li>unu</li><li>doi</li></ul>
}

Pași:

1. html primește o lambda cu receiver HtmlBuilder. 2. HtmlBuilder().apply(block) rulează lambda cu builder-ul ca this, deci p(...) înseamnă this.p(...). 3. ul face același lucru cu un ListBuilder, astfel încât li e disponibil doar acolo.

Problema acestui DSL simplu: în interiorul lui ul { }, receptorul exterior HtmlBuilder e încă vizibil, deci p("x") scris acolo compilează și produce HTML greșit. Soluția este o adnotare marcată cu @DslMarker, aplicată ambelor clase de builder, care interzice folosirea implicită a receptorilor exteriori.

Într-un DSL real ai escapa și textul (caracterele <, &), ca să nu produci HTML invalid sau vulnerabil la injectare.

Ce urmărește intervievatorul: Verifică înțelegerea lambda-urilor cu receiver, baza DSL-urilor din ecosistemul Kotlin. Candidații buni menționează și @DslMarker.

72 Senior

Cum poate o funcție scrisă de tine să-i spună compilatorului că, dacă întoarce true, argumentul nu e null? Ce sunt contractele în Kotlin și ce riscuri au?

Răspuns scurt: Prin contracte (kotlin.contracts): în corpul funcției declari contract { returns(true) implies (x != null) }, iar compilatorul face smart cast după apel. API-ul e încă experimental, iar compilatorul nu verifică dacă promisiunea e adevărată.

Analiza compilatorului se oprește la granița funcțiilor: după if (isValid(x)), el nu știe ce a verificat isValid. Funcțiile standard ca isNullOrEmpty, require sau check permit totuși smart cast, pentru că declară contracte.

KOTLIN
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract

@OptIn(ExperimentalContracts::class)
fun String?.isValidName(): Boolean {
    contract { returns(true) implies (this@isValidName != null) }
    return this != null && length in 2..50
}

@OptIn(ExperimentalContracts::class)
inline fun <T> measured(block: () -> T): T {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
    return block()
}

fun greet(name: String?) {
    if (name.isValidName()) println(name.length)    // smart cast la String

    val total: Int
    measured { total = 42 }      // permis: blocul rulează exact o dată
    println(total)
}

Tipuri de contracte:

  • returns(valoare) implies (condiție): legătura dintre rezultat și o condiție de tip sau de nulabilitate;
  • callsInPlace(lambda, kind): garanția că lambda e apelată pe loc, o dată sau de cel puțin o dată, ceea ce permite inițializarea unui val în interiorul ei.

Riscurile:

  • Compilatorul nu verifică contractul. Dacă implementarea nu respectă promisiunea, introduci un NullPointerException sau un ClassCastException acolo unde sistemul de tipuri pretinde că nu e posibil.
  • API-ul este experimental și cere opt-in. Forma lui s-a mai schimbat între versiuni, deci într-o bibliotecă publică trebuie folosit cu grijă.
  • Contractul trebuie să fie prima instrucțiune din funcție și funcționează doar pentru funcții de nivel superior sau finale.

Folosește contractele pentru funcții utilitare mici, bine testate, unde câștigul de lizibilitate la apel este mare.

Ce urmărește intervievatorul: La senior se verifică înțelegerea mecanismelor prin care biblioteca standard extinde analiza compilatorului. Contează mai ales conștientizarea riscului de contract greșit.

Coroutines

73 Junior

În ce ordine se afișează numerele? Ce face runBlocking și unde nu trebuie folosit?

KOTLIN
import kotlinx.coroutines.*

fun main() {
    println("1")
    runBlocking {
        launch {
            delay(100)
            println("3")
        }
        println("2")
    }
    println("4")
}

Răspuns scurt: Afișează 1, 2, 3, 4. runBlocking pornește o corutină și blochează thread-ul curent până se termină ea și toți copiii ei. Se folosește în main sau în teste simple, nu în codul de aplicație și nu în interiorul altor corutine.

Pas cu pas:

1. Se afișează „1” din codul obișnuit. 2. runBlocking creează un scope de corutine și blochează thread-ul main până când tot ce rulează în el se termină. 3. launch pornește o corutină copil, dar nu o execută imediat. O programează și continuă. 4. Se afișează „2”. 5. Blocul lui runBlocking s-a terminat, dar scope-ul așteaptă copilul. Copilul rulează, ajunge la delay(100), se suspendă, iar după 100 ms afișează „3”. 6. Abia acum runBlocking se întoarce și se afișează „4”.

Ordinea „2” înainte de „3” arată două lucruri: launch nu blochează, iar scope-ul nu se încheie până nu se termină copiii. Acesta este principiul structured concurrency.

De ce nu folosești runBlocking oriunde:

  • Blochează un thread real. Pe thread-ul principal al unei interfețe grafice, aplicația îngheață.
  • Într-o corutină sau într-o funcție suspend, blocarea thread-ului anulează avantajul corutinelor și poate produce deadlock dacă dispecerul are puține thread-uri.
  • Pe un server, fiecare runBlocking într-un handler de cereri ocupă un thread din pool.

Unde e potrivit: ca punte între codul obișnuit și cel cu corutine, de exemplu în main sau într-un utilitar de linie de comandă. Pentru teste, runTest din kotlinx-coroutines-test e mai bun, pentru că sare peste întârzieri virtual și testul rulează instant. Alternativa pentru main este suspend fun main(), permisă direct de Kotlin.

Ce urmărește intervievatorul: Verifică înțelegerea de bază a programării corutinelor și a rolului lui runBlocking. Greșeala tipică este folosirea lui în codul de producție ca să „scapi” de suspend.

Eroarea, în practică:Suspend function can only be called from a coroutine

74 Junior

Ce afișează programul, în ce ordine, și pe câte thread-uri rulează?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        repeat(3) { i -> println("A$i"); delay(100) }
    }
    launch {
        repeat(3) { i -> println("B$i"); delay(150) }
    }
}

Răspuns scurt: Afișează A0, B0, A1, B1, A2, B2, cu momente de pornire la 0, 0, 100, 150, 200 și 300 ms. Totul rulează pe un singur thread: corutinele se alternează la punctele de suspendare, adică la fiecare delay.

runBlocking folosește o buclă de evenimente pe thread-ul curent. Ambele launch sunt programate pe același thread, iar execuția trece de la o corutină la alta doar când una se suspendă.

Cronologia:

  • la 0 ms: A afișează A0 și se suspendă pentru 100 ms; B afișează B0 și se suspendă pentru 150 ms;
  • la 100 ms: A reia, afișează A1, se suspendă până la 200 ms;
  • la 150 ms: B afișează B1, se suspendă până la 300 ms;
  • la 200 ms: A2;
  • la 300 ms: B2.

Concluzii importante:

  • Concurența nu înseamnă paralelism. Două corutine progresează în același interval de timp, dar pe un singur thread nu rulează niciodată simultan.
  • delay nu blochează thread-ul, ci suspendă corutina și eliberează thread-ul pentru alte corutine. Cu Thread.sleep(100), cele două ar rula una după alta.
  • Programul durează aproximativ 450 ms (ultimul delay(150) după B2), nu suma tuturor întârzierilor.

Dacă pornești corutinele cu launch(Dispatchers.Default), ele pot rula pe thread-uri diferite, în paralel, iar ordinea afișării devine nedeterministă când momentele coincid. Pe un singur thread, ordinea e previzibilă pentru întârzieri diferite. Codul corect nu ar trebui însă să depindă de ordinea dintre corutine independente: dacă ordinea contează, o exprimi explicit cu join, await sau canale.

Ce urmărește intervievatorul: Se verifică modelul mental al corutinelor: suspendare, nu blocare. Candidații care confundă concurența cu paralelismul greșesc frecvent aici.

75 Junior

Cât durează aproximativ fiecare variantă și de ce?

KOTLIN
import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis

suspend fun loadUser(): String { delay(1000); return "Ana" }
suspend fun loadOrders(): Int { delay(1000); return 3 }

fun main() = runBlocking {
    val t1 = measureTimeMillis {
        val u = loadUser()
        val o = loadOrders()
        println("$u $o")
    }
    val t2 = measureTimeMillis {
        val u = async { loadUser() }
        val o = async { loadOrders() }
        println("${u.await()} ${o.await()}")
    }
    println("$t1 $t2")
}

Răspuns scurt: Prima variantă durează în jur de 2000 ms, pentru că apelurile suspend rulează secvențial. A doua durează în jur de 1000 ms, pentru că async pornește ambele operații imediat și abia apoi aștepți rezultatele.

Apelurile suspend sunt secvențiale implicit. Codul arată ca unul sincron: loadOrders începe doar după ce loadUser s-a terminat. E un avantaj, pentru că ordinea e evidentă, dar înseamnă că două operații independente se adună.

async pornește o corutină copil care calculează o valoare și întoarce imediat un Deferred<T>. await() suspendă până când valoarea e gata. Ambele async sunt pornite înaintea primului await, deci așteptările se suprapun și timpul total e aproximativ cel al operației mai lungi.

Greșeala clasică este așteptarea imediată:

KOTLIN
val u = async { loadUser() }.await()     // așteaptă aici
val o = async { loadOrders() }.await()   // pornește abia acum: tot ~2000 ms

Variantă idiomatică pentru mai multe operații de același tip:

KOTLIN
val results = ids.map { id -> async { loadItem(id) } }.awaitAll()

Detalii de reținut:

  • async are sens doar pentru operații independente. Dacă a doua are nevoie de rezultatul primei, apelul secvențial e corect.
  • Erorile dintr-un async care rulează în coroutineScope anulează scope-ul și corutinele surori, apoi se propagă. Nu se pierd.
  • Pentru zeci de mii de cereri simultane, limitezi concurența, de exemplu cu un Semaphore, ca să nu suprasoliciți serverul sau baza de date.

Timpii măsurați vor fi puțin peste 1000 și 2000 ms, din cauza costului de programare a corutinelor.

Ce urmărește intervievatorul: Verifică dacă știi să paralelizezi corect operații independente. Greșeala tipică este async { }.await() imediat.

Eroarea, în practică:Unresolved reference 'await' on 'Job'

76 Junior

Cât durează programul de mai jos? Ce se schimbă dacă înlocuiești Thread.sleep(1000) cu delay(1000)?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    repeat(3) { i ->
        launch {
            Thread.sleep(1000)
            println("gata $i")
        }
    }
}

Răspuns scurt: Durează aproximativ 3 secunde, pentru că Thread.sleep blochează singurul thread al lui runBlocking, iar corutinele rulează una după alta. Cu delay(1000) durează aproximativ o secundă, pentru că delay doar suspendă corutina și eliberează thread-ul.

Corutinele lansate în runBlocking împart un singur thread. Ca să alterneze, fiecare trebuie să ajungă la un punct de suspendare. Thread.sleep nu e o funcție suspend: blochează thread-ul. Prima corutină ține thread-ul ocupat o secundă, apoi a doua, apoi a treia, deci totalul e de aproximativ 3 secunde.

delay este o funcție suspend: programează reluarea corutinei peste o secundă și eliberează imediat thread-ul. Toate trei încep să aștepte aproape simultan și termină împreună după aproximativ o secundă.

Regula: în corutine nu apelezi cod care blochează thread-ul pe dispecerul curent. Exemple de cod blocant: Thread.sleep, citiri din fișiere cu java.io, JDBC, apeluri HTTP sincrone, future.get(), așteptarea unui lock Java.

Când ai cod blocant pe care nu-l poți rescrie, îl muți pe un dispecer potrivit:

KOTLIN
suspend fun readConfig(path: String): String =
    withContext(Dispatchers.IO) {
        java.io.File(path).readText()     // blochează un thread din pool-ul IO
    }

Dispatchers.IO are un pool mare de thread-uri, gândit pentru operații care stau în așteptare. Dispatchers.Default are aproximativ atâtea thread-uri câte nuclee are procesorul și e pentru calcul intens. Un cod blocant pus pe Default ocupă thread-uri care ar trebui să facă alte calcule.

Simptome ale codului blocant ascuns într-o aplicație: interfața care îngheață, cereri de server care stau la coadă fără motiv aparent, teste care durează mai mult decât suma întârzierilor așteptate.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre suspendare și blocare, cea mai importantă idee din corutine. Candidații slabi cred că orice cod din launch rulează automat în paralel.

77 Mid

Care e diferența dintre withContext(Dispatchers.IO) { ... } și launch(Dispatchers.IO) { ... }? Ce înseamnă că o funcție suspend este „main-safe”?

Răspuns scurt: withContext mută blocul pe alt dispecer, suspendă apelantul și întoarce rezultatul. launch pornește o corutină nouă și întoarce imediat un Job. O funcție main-safe poate fi apelată de pe orice thread, pentru că își mută singură munca grea.

withContext(dispatcher) { } nu creează o corutină paralelă. Corutina curentă trece pe alt dispecer pentru durata blocului, apoi revine la contextul inițial cu rezultatul. Execuția rămâne secvențială:

KOTLIN
suspend fun loadReport(id: Long): Report {
    val raw = withContext(Dispatchers.IO) { db.readReport(id) }   // I/O blocant
    return withContext(Dispatchers.Default) { parse(raw) }        // calcul intens
}

launch(dispatcher) { } pornește o corutină nouă, cu propriul Job. Codul de după launch continuă imediat, fără să aștepte, iar launch nu întoarce o valoare. E potrivit pentru operații de tip „pornește și uită” într-un scope controlat, nu pentru a obține un rezultat.

Greșeli frecvente:

  • launch(Dispatchers.IO) { result = load() } urmat de folosirea lui result, care încă nu e calculat;
  • withContext cu același dispecer pe care ești deja, ceea ce e inutil, deși costul e mic;
  • async(Dispatchers.IO) { }.await() imediat, care e un withContext scris mai complicat.

Main-safety este o convenție de design: o funcție suspend nu ar trebui să blocheze apelantul, indiferent de thread. Funcția care face I/O își mută singură munca pe Dispatchers.IO, astfel încât codul de interfață o poate apela fără griji. Bibliotecile moderne (Retrofit cu funcții suspend, Room, Ktor client) respectă deja convenția.

Ca să poți testa, injectezi dispecerul ca parametru în constructor, în loc să-l scrii direct în cod, și îl înlocuiești în teste cu un dispecer de test.

Ce urmărește intervievatorul: Verifică dacă știi să alegi între schimbarea contextului și lansarea unei corutine noi. Confuzia dintre ele produce race conditions și date necalculate.

78 Mid

Ce afișează programul? Care e diferența dintre coroutineScope și supervisorScope?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        coroutineScope {
            launch { delay(100); throw IllegalStateException("eșec 1") }
            launch { delay(500); println("copilul 2 a terminat") }
        }
    } catch (e: IllegalStateException) {
        println("Prins: ${e.message}")
    }

    supervisorScope {
        launch { delay(100); throw IllegalStateException("eșec 2") }
        launch { delay(500); println("copilul 2 (supervisor) a terminat") }
    }
}

Răspuns scurt: Afișează Prins: eșec 1, apoi stack trace-ul pentru „eșec 2”, scris de handler-ul implicit, și copilul 2 (supervisor) a terminat. În coroutineScope, eșecul unui copil anulează frații și se propagă. În supervisorScope, copiii eșuează independent.

coroutineScope creează un scope care așteaptă toți copiii și aplică regula strictă a concurenței structurate: dacă un copil eșuează, scope-ul anulează ceilalți copii și aruncă excepția mai departe, către apelant. De aceea al doilea launch din prima parte nu apucă să afișeze nimic, iar excepția ajunge în catch.

E potrivit când operațiile formează un întreg: dacă nu poți încărca profilul, nu are rost să aștepți și comenzile pentru aceeași pagină.

supervisorScope folosește un SupervisorJob: eșecul unui copil nu afectează frații și nici scope-ul. Excepția copilului lansat cu launch trebuie tratată de acel copil. Dacă nu e tratată, ajunge la CoroutineExceptionHandler din context sau, în lipsa lui, la handler-ul implicit, care pe JVM afișează stack trace-ul. Al doilea copil își termină treaba.

E potrivit pentru sarcini independente: mai multe widget-uri pe un ecran, mai multe fișiere descărcate, mai mulți clienți serviți.

Diferențe practice:

  • Cu async în supervisorScope, excepția nu se propagă automat, ci apare la await(), unde o poți prinde individual.
  • Un try/catch în jurul lui launch nu prinde excepția aruncată în interiorul corutinei, pentru că launch se întoarce imediat. Prinzi excepția în corutină sau la nivelul scope-ului.
  • Ambele funcții sunt suspend și se întorc doar când toți copiii s-au terminat.

Alegerea între ele este o decizie de business: eșuează totul sau doar partea afectată?

Ce urmărește intervievatorul: Verifică înțelegerea propagării erorilor în ierarhia de corutine. Candidații care nu știu ce face handler-ul implicit nu pot explica rezultatul complet.

79 Mid

Ce se întâmplă după job.cancel()? Unde e bug-ul?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        while (true) {
            try {
                delay(500)
                println("lucrez")
            } catch (e: Exception) {
                println("eroare: $e")
            }
        }
    }
    delay(1200)
    job.cancel()
    job.join()
    println("oprit")
}

Răspuns scurt: Programul nu se oprește niciodată. După cancel, delay aruncă CancellationException, care e prinsă ca Exception și ignorată. Bucla continuă, iar delay aruncă imediat din nou, la infinit. Repari rearuncând CancellationException sau prinzând doar excepțiile așteptate.

Anularea în corutine este cooperativă: cancel() doar marchează job-ul ca anulat. Funcțiile suspend din kotlinx.coroutines (delay, withContext, yield, await) verifică starea și aruncă CancellationException, iar această excepție, propagată normal, oprește corutina.

catch (e: Exception) prinde și CancellationException, care e o subclasă de IllegalStateException, deci de Exception. Corutina își înghite propria anulare. Pentru că job-ul rămâne anulat, fiecare delay aruncă imediat, iar bucla se rotește fără pauză, ocupând procesorul și umplând consola cu „eroare”. job.join() nu se termină niciodată.

Variante corecte:

KOTLIN
val job = launch {
    while (isActive) {
        try {
            delay(500)
            println("lucrez")
        } catch (e: CancellationException) {
            throw e                          // nu înghiți anularea
        } catch (e: Exception) {
            println("eroare: $e")
        }
    }
}

Sau prinzi doar ce aștepți: catch (e: IOException).

Aceeași capcană apare cu runCatching, care prinde Throwable, deci și anularea. Un runCatching { api.load() } într-o corutină poate face ca o corutină anulată să continue ca și cum nimic nu s-ar fi întâmplat. Soluția este să verifici rezultatul sau să apelezi coroutineContext.ensureActive() după el.

isActive și ensureActive() sunt utile și în bucle de calcul fără funcții suspend. Fără ele, o astfel de buclă nu observă niciodată anularea.

Ce urmărește intervievatorul: Este un bug foarte des întâlnit în cod real. Se verifică dacă știi că anularea se face prin excepție și că un catch generic o poate înghiți.

80 Mid

Care e diferența dintre withTimeout și withTimeoutOrNull? Ce capcană are TimeoutCancellationException când apare într-un launch?

Răspuns scurt: Ambele anulează blocul după timpul dat. withTimeout aruncă TimeoutCancellationException, iar withTimeoutOrNull întoarce null. Excepția este o subclasă de CancellationException, deci, nefiind prinsă într-un launch, oprește corutina în tăcere, fără să fie raportată ca eroare.

Exemplu:

KOTLIN
val result: String? = withTimeoutOrNull(500) {
    delay(1000)
    "gata"
}
println(result)          // null

try {
    withTimeout(500) { delay(1000) }
} catch (e: TimeoutCancellationException) {
    println("Timeout: ${e.message}")
}

Cum funcționează: după expirarea timpului, blocul este anulat cooperativ. Următorul punct de suspendare din bloc aruncă TimeoutCancellationException. Un cod blocant (de exemplu un apel JDBC sincron) nu este întrerupt; timeout-ul se aplică abia după ce codul blocant se termină, ceea ce poate fi mult mai târziu.

Capcana: pentru că TimeoutCancellationException este un CancellationException, mecanismul de corutine o tratează ca pe o anulare normală, nu ca pe un eșec:

KOTLIN
scope.launch {
    withTimeout(1000) { api.sync() }   // dacă expiră, corutina se oprește
    println("sincronizat")              // nu ajunge aici
}                                       // și nimic nu e raportat ca eroare

Niciun CoroutineExceptionHandler nu este apelat și nu apare nimic în log-urile de crash. Problema dispare fără urmă. De aceea, într-un launch, preferi withTimeoutOrNull și tratezi explicit null, sau prinzi excepția și o transformi într-o eroare de domeniu.

Alte detalii:

  • Resursele deschise în bloc trebuie închise în finally sau cu use, pentru că timeout-ul poate apărea oricând.
  • Pentru cereri HTTP, timeout-urile clientului (conectare, citire) sunt de obicei mai potrivite decât un withTimeout în jur, pentru că eliberează și conexiunea.

Ce urmărește intervievatorul: Verifică înțelegerea fină a timeout-urilor și a relației lor cu anularea. Puțini candidați știu că un timeout într-un launch poate trece neobservat.

Eroarea, în practică:TimeoutCancellationException: Timed out waiting

81 Mid

Ce afișează programul? Ce se întâmplă cu copiii unui Job când părintele e anulat?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    val parent = launch {
        launch { delay(1000); println("copil 1") }
        launch { delay(2000); println("copil 2") }
    }
    delay(1500)
    parent.cancelAndJoin()
    println("anulat: ${parent.isCancelled}, terminat: ${parent.isCompleted}")
}

Răspuns scurt: Afișează copil 1 după o secundă și apoi anulat: true, terminat: true. Anularea părintelui anulează automat toți copiii, deci „copil 2” nu apare. cancelAndJoin așteaptă ca anularea să se finalizeze complet.

Fiecare corutină are un Job, care îi reprezintă ciclul de viață. Corutinele lansate în interiorul alteia devin copiii ei și formează un arbore. Reguli:

  • un părinte nu se termină până nu se termină toți copiii;
  • anularea părintelui anulează recursiv toți copiii;
  • eșecul unui copil (cu altă excepție decât anularea) anulează părintele și frații, dacă nu e folosit un SupervisorJob.

Stările unui Job: New (doar la pornire leneșă), Active, Completing (corpul s-a terminat, așteaptă copiii), Completed, apoi Cancelling și Cancelled la anulare. Proprietățile isActive, isCompleted și isCancelled le reflectă. După anulare, isCompleted devine true doar după ce toți copiii s-au oprit.

În exemplu:

  • la 1000 ms, primul copil afișează „copil 1” și se termină;
  • la 1500 ms, cancel() anulează părintele și pe al doilea copil, aflat în delay;
  • join() așteaptă finalizarea, pentru că un copil poate avea cod de curățare în finally.

Funcții utile:

KOTLIN
val job = launch(start = CoroutineStart.LAZY) { work() }
job.start()                 // pornire explicită
job.join()                  // așteaptă terminarea
job.cancel()                // cere anularea, nu așteaptă
job.invokeOnCompletion { cause -> println("terminat, cauza: $cause") }

Deferred<T> (de la async) extinde Job și adaugă await(). Dacă transmiți explicit un Job() nou ca parametru, de exemplu launch(Job()) { }, corutina iese din arbore: părintele nu o mai așteaptă și nu o mai anulează. E o sursă frecventă de corutine „scăpate” de sub control.

Ce urmărește intervievatorul: Verifică înțelegerea ierarhiei de job-uri, baza concurenței structurate. Mulți candidați nu știu că transmiterea unui Job() nou rupe legătura cu părintele.

Eroarea, în practică:JobCancellationException: was cancelled

82 Senior

De ce nu se afișează „curățenie terminată” în varianta fără NonCancellable? Ce afișează codul de mai jos?

KOTLIN
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i -> println("pas $i"); delay(300) }
        } finally {
            withContext(NonCancellable) {
                delay(100)
                println("curățenie terminată")
            }
        }
    }
    delay(700)
    job.cancelAndJoin()
    println("gata")
}

Răspuns scurt: Afișează pas 0, pas 1, pas 2, curățenie terminată și gata. Într-o corutină anulată, orice funcție suspend din finally aruncă imediat CancellationException. withContext(NonCancellable) rulează blocul de curățare ignorând anularea.

Pașii afișați corespund momentelor 0, 300 și 600 ms. La 700 ms corutina e anulată în timpul lui delay, care aruncă CancellationException, iar execuția intră în finally.

Problema: corutina este încă în starea anulată. Codul obișnuit din finally rulează, dar orice apel suspend cooperativ verifică starea și aruncă din nou. Fără NonCancellable, delay(100) ar arunca imediat, iar mesajul nu ar mai fi afișat. În cod real, asta înseamnă că nu poți închide o conexiune prin rețea, nu poți scrie o stare finală în baza de date și nu poți trimite un mesaj de deconectare.

NonCancellable este un Job special, mereu activ. Folosit cu withContext, el creează un context în care apelurile suspend nu observă anularea, iar curățarea se termină. cancelAndJoin așteaptă și această curățare înainte să se afișeze „gata”.

Reguli de folosire:

  • doar în finally sau în cod de curățare, pentru operații scurte;
  • niciodată ca argument pentru launch sau async. O corutină pornită cu NonCancellable nu mai e copil al nimănui, deci nu poate fi anulată și nu e așteptată;
  • combinat, dacă e nevoie, cu withTimeout, ca o curățare blocată să nu țină aplicația în viață la nesfârșit.

Curățarea care nu are nevoie de suspendare (eliberarea unui lock, închiderea sincronă a unui fișier, use { }) funcționează normal în finally, fără nimic special.

Alternativ, pentru resurse cu ciclu de viață legat de un job, invokeOnCompletion sau awaitClose (în callbackFlow) sunt locuri dedicate pentru curățare.

Ce urmărește intervievatorul: La senior se verifică stăpânirea anulării până în detaliile de curățare a resurselor. Candidații slabi presupun că finally din corutine se comportă ca cel obișnuit.

83 Senior

Cum funcționează o funcție suspend la nivelul bytecode-ului? Ce înseamnă continuation-passing style și state machine?

Răspuns scurt: Compilatorul adaugă fiecărei funcții suspend un parametru ascuns Continuation și o transformă într-o mașină de stări: fiecare punct de suspendare devine o stare, iar variabilele locale sunt salvate într-un obiect. Funcția întoarce fie rezultatul, fie marcajul COROUTINE_SUSPENDED.

Corutinele Kotlin sunt implementate în compilator, nu în JVM. O funcție

KOTLIN
suspend fun loadProfile(id: Long): Profile {
    val user = api.user(id)          // punct de suspendare 1
    val orders = api.orders(id)      // punct de suspendare 2
    return Profile(user, orders)
}

devine, conceptual, fun loadProfile(id: Long, cont: Continuation<Profile>): Any?. Acesta este continuation-passing style (CPS): în loc să întoarcă direct rezultatul, funcția primește un obiect care știe „ce urmează după”.

În corp, compilatorul generează o mașină de stări:

  • un obiect continuation specific funcției păstrează un label (starea curentă) și câmpuri pentru variabilele locale care trebuie să supraviețuiască suspendării (id, user);
  • la fiecare punct de suspendare, funcția apelează funcția suspend interioară cu propriul continuation. Dacă aceasta întoarce COROUTINE_SUSPENDED, funcția se oprește și eliberează thread-ul;
  • când operația se termină, cineva apelează resumeWith(result) pe continuation, care reintră în funcție cu label-ul salvat și continuă de la starea următoare.

Consecințe practice:

  • Corutinele sunt stackless: o corutină suspendată nu ține ocupat un stack de thread, ci doar câteva obiecte mici pe heap. De aceea poți avea sute de mii de corutine.
  • Funcțiile suspend pot fi apelate doar din alte funcții suspend sau din builderi de corutine, pentru că au nevoie de un continuation.
  • Stack trace-urile sunt fragmentate, pentru că după reluare stack-ul real nu mai conține apelanții originali. kotlinx-coroutines-debug și modul de depanare reconstruiesc lanțul.
  • O funcție suspend care nu se suspendă niciodată efectiv rulează aproape ca una obișnuită, cu un cost mic pentru obiectul continuation.

Ce urmărește intervievatorul: La senior se verifică înțelegerea modelului de implementare, utilă la depanare și la evaluarea performanței. Răspunsurile vagi de tipul „sunt thread-uri ușoare” nu sunt suficiente.

Eroarea, în practică:Suspend function can only be called from a coroutine

84 Senior

Ai o bibliotecă veche, cu un API bazat pe callback-uri, care întoarce un singur rezultat. Cum o transformi într-o funcție suspend care respectă anularea?

KOTLIN
interface Callback<T> {
    fun onSuccess(value: T)
    fun onError(e: Throwable)
}

interface Call<T> {
    fun enqueue(cb: Callback<T>)
    fun cancel()
}

Răspuns scurt: Folosești suspendCancellableCoroutine: în bloc pornești cererea, în callback-uri apelezi cont.resume(value) sau cont.resumeWithException(e), iar cu cont.invokeOnCancellation { cancel() } anulezi cererea când corutina e anulată.

KOTLIN
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

suspend fun <T> Call<T>.await(): T = suspendCancellableCoroutine { cont ->
    enqueue(object : Callback<T> {
        override fun onSuccess(value: T) {
            cont.resume(value)
        }
        override fun onError(e: Throwable) {
            cont.resumeWithException(e)
        }
    })
    cont.invokeOnCancellation { cancel() }
}

// folosire
val user = api.getUser(42).await()

Cum funcționează: suspendCancellableCoroutine suspendă corutina curentă și îți dă obiectul CancellableContinuation. Corutina rămâne suspendată până când cineva o reia. Când callback-ul primește rezultatul, resume repornește corutina pe dispecerul ei, cu valoarea respectivă. O eroare devine o excepție aruncată la punctul de apel, ca într-un cod sincron.

Detalii importante:

  • Reluare o singură dată. Un continuation se poate relua o singură dată. Dacă biblioteca poate apela callback-ul de mai multe ori sau și onSuccess, și onError, ai nevoie de protecție (verificarea cont.isActive). Pentru valori multiple, instrumentul potrivit este callbackFlow, nu o funcție suspend.
  • Anularea. Varianta fără „Cancellable” (suspendCoroutine) nu reacționează la anulare: corutina rămâne agățată până răspunde serverul. invokeOnCancellation oprește și operația de dedesubt, ca să nu consume resurse.
  • Race la anulare. Dacă rezultatul sosește după anulare, resume este ignorat. Dacă valoarea este o resursă (un fișier deschis, o conexiune), o închizi folosind varianta lui resume care primește și un callback onCancellation.
  • Thread-ul callback-ului nu contează: reluarea se face pe dispecerul corutinei.

Multe biblioteci au deja adaptoare (Retrofit cu suspend, kotlinx-coroutines-jdk8 pentru CompletableFuture.await(), Guava, Play Services). Le preferi în locul unei implementări proprii.

Ce urmărește intervievatorul: Verifică abilitatea de a integra cod vechi în corutine fără a pierde anularea. Candidații slabi folosesc runBlocking sau suspendCoroutine fără tratarea anulării.

Eroarea, în practică:IllegalStateException: Already resumed

Flow și canale

Exersează capitolul cu exerciții reale: Curs Kotlin pentru începători →
85 Junior

Ce afișează programul și în ce ordine?

KOTLIN
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val f = (1..5).asFlow()
        .onEach { println("emit $it") }
        .filter { it % 2 == 1 }
        .map { it * 10 }
    println("înainte de collect")
    println(f.take(2).toList())
}

Răspuns scurt: Afișează înainte de collect, emit 1, emit 2, emit 3 și [10, 30]. Operatorii intermediari doar descriu transformarea, iar execuția începe la operatorul terminal toList. take(2) oprește fluxul după al doilea rezultat, deci 4 și 5 nu mai sunt emise.

Un Flow are două feluri de operatori:

  • Intermediari (map, filter, onEach, take, debounce): întorc un nou Flow și nu execută nimic. Sunt rapizi și nu sunt suspend.
  • Terminali (collect, toList, first, single, reduce, count, launchIn): sunt funcții suspend care pornesc efectiv fluxul și consumă valorile.

De aceea mesajul „înainte de collect” apare primul: construirea lanțului nu emite nimic.

Odată pornit, fiecare valoare trece prin tot lanțul înainte să fie emisă următoarea, la fel ca la secvențe:

  • 1 este emis, trece de filter, devine 10 și e colectat;
  • 2 este emis și eliminat de filter;
  • 3 este emis, devine 30, iar take(2) a primit acum două valori și anulează restul fluxului.

take oprește producătorul prin anulare: sursa primește o excepție internă de anulare la următorul emit, iar codul din finally al producătorului rulează.

Dacă ai colecta fluxul f de două ori, totul s-ar relua de la început, inclusiv mesajele „emit”. Fiecare colectare pornește din nou producătorul.

Operatorii terminali frecvenți:

KOTLIN
val first = f.first()                    // prima valoare, apoi anulează
val all = f.toList()
val sum = f.fold(0) { acc, v -> acc + v }
f.collect { value -> println(value) }

first() aruncă NoSuchElementException dacă fluxul nu emite nimic, iar firstOrNull() întoarce null.

Ce urmărește intervievatorul: Verifică modelul de execuție al lui Flow: lazy și secvențial. Candidații slabi cred că asFlow() emite toate valorile imediat.

86 Junior

Ce afișează codul? Unde prinde catch excepțiile și ce face onCompletion?

KOTLIN
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
import java.io.IOException

fun main() = runBlocking {
    flow {
        emit(1)
        throw IOException("rețea")
    }
        .map { it * 2 }
        .onCompletion { cause -> println("terminat, cauza: $cause") }
        .catch { e -> println("prins: ${e.message}"); emit(-1) }
        .collect { println(it) }
}

Răspuns scurt: Afișează 2, terminat, cauza: java.io.IOException: rețea, prins: rețea și -1. catch prinde doar excepțiile apărute deasupra lui în lanț și poate emite o valoare de rezervă, iar onCompletion rulează la orice terminare și vede cauza.

Ordinea în lanț contează, pentru că fiecare operator vede doar ce vine din amonte (upstream):

1. Fluxul emite 1, map îl face 2, iar collect îl afișează. 2. Producătorul aruncă IOException. Excepția urcă prin map și ajunge la onCompletion, care rulează cu cause egal cu excepția și o lasă să treacă mai departe. 3. catch o prinde, afișează mesajul și emite -1, valoare care ajunge la collect. 4. Fluxul se termină normal.

catch este transparent pentru excepțiile din aval: o excepție aruncată în blocul collect nu este prinsă de un catch pus înainte. Ca să prinzi și erorile de procesare, muți logica în onEach:

KOTLIN
flow
    .onEach { value -> process(value) }     // aici pot apărea erori
    .catch { e -> log(e) }
    .launchIn(scope)

onCompletion e echivalentul unui finally: rulează la terminare normală (cause == null), la eroare și la anulare. E potrivit pentru ascunderea unui indicator de încărcare sau pentru log.

retry și retryWhen reiau fluxul de la sursă când apare o eroare:

KOTLIN
flow.retry(3) { e -> e is IOException }

Funcționează pentru că fluxurile reci se pot reporni. Pentru încercări cu pauză, retryWhen { cause, attempt -> delay(1000L * attempt); attempt < 3 }.

După ce catch a prins excepția, fluxul original nu mai continuă. Dacă vrei ca un flux pe termen lung (de exemplu actualizări periodice) să supraviețuiască erorilor, tratezi erorile în interiorul fiecărei operații, nu la nivelul întregului flux.

Ce urmărește intervievatorul: Verifică înțelegerea propagării erorilor în Flow și a poziției operatorilor. Mulți candidați cred că catch prinde și erorile din collect.

87 Junior

Care e diferența dintre un Channel și un Flow? Ce capacități poate avea un canal și ce se întâmplă când e plin?

Răspuns scurt: Un Flow e rece: nu produce nimic până nu e colectat și fiecare colector își pornește propria execuție. Un Channel e cald: e o coadă între corutine, fiecare valoare ajunge la un singur consumator, iar send se suspendă când bufferul e plin.

Channel este un mecanism de comunicare între corutine, asemănător unei cozi blocante, dar cu suspendare în loc de blocare:

KOTLIN
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel

fun main() = runBlocking {
    val channel = Channel<Int>(capacity = 2)
    launch {
        for (i in 1..5) channel.send(i)   // se suspendă când bufferul e plin
        channel.close()                    // semnalează că nu mai vin valori
    }
    for (x in channel) {                   // se termină după close
        delay(100)
        println("primit $x")
    }
}

Capacități:

  • RENDEZVOUS (implicit, 0): send așteaptă până când cineva face receive, un fel de „predare din mână în mână”;
  • un număr fix (de exemplu 2): buffer de acea mărime;
  • BUFFERED: buffer cu dimensiune implicită (64 de elemente, configurabil);
  • UNLIMITED: fără limită, cu risc de consum nelimitat de memorie dacă consumatorul e lent;
  • CONFLATED: păstrează doar ultima valoare, iar cele vechi se pierd.

Parametrul onBufferOverflow (SUSPEND, DROP_OLDEST, DROP_LATEST) alege ce se întâmplă când bufferul e plin.

Diferențe față de Flow:

  • Un canal există independent de consumatori. Valorile trimise stau în buffer până sunt preluate, iar dacă nimeni nu citește, producătorul rămâne suspendat.
  • Cu mai mulți consumatori, valorile sunt împărțite (fan-out), nu copiate la fiecare.
  • Canalele trebuie închise explicit, altfel un consumator cu for așteaptă la nesfârșit.

Când folosești canale: tipare producător-consumator, cozi de lucru împărțite între mai mulți workeri, comunicare între corutine de lungă durată. Pentru fluxuri de date expuse către alte părți ale aplicației, Flow, StateFlow și SharedFlow sunt de obicei mai potrivite.

Ce urmărește intervievatorul: Verifică dacă știi când să folosești fiecare primitivă. Greșeala tipică este folosirea unui Channel acolo unde un Flow ar fi mai simplu și mai sigur.

Eroarea, în practică:ClosedSendChannelException: Channel was closedgetOrThrow on a failed channel result

88 Mid

Pe ce thread rulează fiecare parte a lanțului de mai jos? De ce nu e voie să folosești withContext în jurul lui emit?

KOTLIN
fun numbers(): Flow<Int> = flow {
    println("producător pe ${Thread.currentThread().name}")
    emit(heavyCompute())
}
    .map { it + 1 }
    .flowOn(Dispatchers.Default)

// colectat din corutina principală:
numbers().collect { println("colector pe ${Thread.currentThread().name}") }

Răspuns scurt: flowOn schimbă contextul doar pentru partea din amonte (flow { } și map), care rulează pe Dispatchers.Default. collect rulează în contextul colectorului. Un emit din alt context încalcă regula de context preservation și aruncă IllegalStateException.

Un Flow respectă context preservation: valorile ajung la colector în contextul în care acesta a apelat collect. Colectorul nu trebuie să se aștepte ca blocul lui să ruleze brusc pe alt thread.

flowOn(dispatcher) este modul corect de a muta producătorul pe alt dispecer. Afectează toți operatorii de deasupra lui până la precedentul flowOn. Intern, creează un buffer (un canal) între cele două contexte, deci producătorul și colectorul pot lucra concurent.

KOTLIN
flow { emit(readFromDisk()) }   // pe IO
    .flowOn(Dispatchers.IO)
    .map { parse(it) }          // pe Default
    .flowOn(Dispatchers.Default)
    .collect { show(it) }       // în contextul colectorului

De ce withContext în jurul lui emit e interzis:

KOTLIN
flow {
    withContext(Dispatchers.IO) {
        emit(load())   // IllegalStateException: Flow invariant is violated
    }
}

emit ar chema blocul colectorului pe thread-ul IO, încălcând contractul. Varianta corectă este să calculezi valoarea în alt context și să emiți în contextul original:

KOTLIN
flow {
    val data = withContext(Dispatchers.IO) { load() }
    emit(data)
}

Dacă ai nevoie să emiți din mai multe corutine sau din contexte diferite, folosești channelFlow, unde send e sigur în orice context.

În practică, funcțiile din repository-uri care întorc Flow aplică singure flowOn(Dispatchers.IO), la fel ca funcțiile suspend main-safe, iar codul care le colectează nu trebuie să știe unde se face munca.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de context al lui Flow. Eroarea „Flow invariant is violated” apare des la cei care trec de la RxJava sau scriu withContext din reflex.

89 Mid

Scrie un flux pentru o căutare: primești textul tastat ca Flow<String> și trebuie să apelezi API-ul doar după ce utilizatorul s-a oprit din tastat 300 ms, pentru minim 2 caractere, fără cereri duplicate și anulând cererea veche când apare text nou.

Răspuns scurt: Lanțul este map { it.trim() }, debounce(300), filter { it.length >= 2 }, distinctUntilChanged() și flatMapLatest { q -> flow { emit(api(q)) } }, cu catch în interiorul fluxului interior, ca o eroare să nu oprească întreaga căutare.

KOTLIN
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.flow.*

@OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
fun searchResults(
    queries: Flow<String>,
    api: suspend (String) -> List<String>
): Flow<List<String>> =
    queries
        .map { it.trim() }
        .debounce(300)
        .filter { it.length >= 2 }
        .distinctUntilChanged()
        .flatMapLatest { q ->
            flow { emit(api(q)) }
                .catch { emit(emptyList()) }
        }

Rolul fiecărui operator:

  • debounce(300) emite o valoare doar dacă după ea nu a venit alta timp de 300 ms. Literele tastate rapid nu produc cereri.
  • filter elimină interogările prea scurte.
  • distinctUntilChanged evită o cerere nouă când textul nu s-a schimbat efectiv, de exemplu după ce utilizatorul a adăugat și a șters un spațiu.
  • flatMapLatest pornește un flux interior pentru fiecare interogare și anulează fluxul precedent când vine una nouă. Rezultatele unei cereri vechi, mai lente, nu suprascriu rezultatele noi. flatMapConcat ar aștepta fiecare cerere, iar flatMapMerge le-ar rula în paralel și ar amesteca rezultatele.
  • catch în interiorul lui flatMapLatest tratează eroarea unei singure cereri. Pus la final, după prima eroare ar opri tot fluxul și căutarea nu ar mai funcționa.

Îmbunătățiri de discutat: emiterea unei stări „se încarcă” la începutul fluxului interior, un tip de rezultat sealed (Loading, Success, Error) în loc de listă goală la eroare și o interogare goală care golește rezultatele în loc să fie ignorată.

Testarea se face cu runTest, unde timpul virtual permite verificarea lui debounce fără așteptări reale.

Ce urmărește intervievatorul: Este o problemă clasică de interviu care verifică operatorii avansați de Flow. Diferența dintre flatMapLatest, flatMapConcat și flatMapMerge e esențială aici.

90 Senior

Producătorul emite o valoare la fiecare 100 ms, iar colectorul are nevoie de 300 ms pentru fiecare. Ce se întâmplă, cât durează și ce afișează fiecare variantă pentru trei valori?

KOTLIN
val f = flow { repeat(3) { delay(100); emit(it) } }

f.collect { delay(300); println(it) }
f.buffer().collect { delay(300); println(it) }
f.conflate().collect { delay(300); println(it) }
f.collectLatest { delay(300); println(it) }

Răspuns scurt: Simplu: 0, 1, 2 în aproximativ 1200 ms. Cu buffer: 0, 1, 2 în aproximativ 1000 ms. Cu conflate: 0 și 2 în aproximativ 700 ms. Cu collectLatest: doar 2, în aproximativ 600 ms. Fiecare variantă alege altfel între completitudine și viteză.

Implicit, un Flow este secvențial: producătorul și colectorul rulează în aceeași corutină, deci emit așteaptă până când colectorul termină valoarea. Asta este backpressure natural, prin suspendare.

  • Fără nimic: fiecare valoare costă 100 ms producție plus 300 ms procesare, deci 3 × 400 = 1200 ms.
  • buffer(): producătorul rulează într-o corutină separată și pune valorile într-un canal. Emite la 100, 200 și 300 ms, iar colectorul procesează de la 100 la 400, de la 400 la 700 și de la 700 la 1000 ms. Toate valorile sunt procesate, iar timpul scade la aproximativ 1000 ms.
  • conflate(): buffer care păstrează doar cea mai recentă valoare. Colectorul începe 0 la 100 ms și e ocupat până la 400 ms. Între timp vin 1 și 2, iar 1 e înlocuit de 2. La 400 ms colectorul primește 2 și termină la 700 ms. Valoarea 1 se pierde.
  • collectLatest: la fiecare valoare nouă, procesarea celei precedente este anulată. 0 e anulat la 200 ms, 1 la 300 ms, iar 2 se procesează complet, terminând la 600 ms.

Cum alegi:

  • buffer când fiecare valoare contează (evenimente de plată, mesaje), iar producătorul și consumatorul pot lucra în paralel;
  • conflate când contează doar starea curentă, iar fiecare procesare trebuie terminată (afișarea unei poziții, a unui preț);
  • collectLatest când procesarea unei valori vechi devine inutilă când apare una nouă (randare de rezultate de căutare).

buffer acceptă și capacitate și onBufferOverflow. conflate() este echivalent cu buffer(CONFLATED). StateFlow aplică deja conflația, de aceea colectorii lenți ai unei stări văd doar valorile cele mai recente.

Ce urmărește intervievatorul: La senior se verifică stăpânirea backpressure-ului și calculul precis al comportamentului în timp. Contează și justificarea alegerii, nu doar mecanismul.

91 Senior

Ai un Flow rece care deschide o conexiune la server și primește prețuri. Mai multe ecrane îl colectează simultan. Ce problemă apare și cum o rezolvi cu stateIn sau shareIn?

Răspuns scurt: Fiecare colector pornește propria execuție a fluxului rece, deci se deschid mai multe conexiuni identice. Cu stateIn sau shareIn, într-un scope cu durată de viață potrivită, transformi fluxul într-unul cald, partajat, cu o singură conexiune pentru toți colectorii.

Un flux construit cu flow { } sau callbackFlow { } este rece: corpul lui rulează separat pentru fiecare collect. Pentru o sursă costisitoare (WebSocket, interogare grea, senzor) asta înseamnă muncă duplicată și, uneori, date inconsistente între colectori.

stateIn transformă fluxul într-un StateFlow, care are mereu o valoare curentă:

KOTLIN
class PriceRepository(scope: CoroutineScope, api: PriceApi) {
    val prices: StateFlow<List<Price>> = api.priceUpdates()
        .stateIn(
            scope = scope,
            started = SharingStarted.WhileSubscribed(5_000),
            initialValue = emptyList()
        )
}

shareIn creează un SharedFlow, fără valoare curentă obligatorie, cu un număr configurabil de valori reluate pentru colectorii noi (replay). E potrivit pentru evenimente, unde nu există o „stare curentă”.

SharingStarted stabilește când rulează sursa:

  • Eagerly: pornește imediat și nu se oprește niciodată, cât trăiește scope-ul;
  • Lazily: pornește la primul colector și nu se mai oprește;
  • WhileSubscribed(stopTimeoutMillis): rulează cât timp există colectori și se oprește după pauza dată de la plecarea ultimului. Pauza acoperă situații scurte, cum ar fi recrearea unui ecran, fără să redeschidă conexiunea.

Capcane:

  • Apelarea lui stateIn într-o funcție (fun prices() = flow.stateIn(...)) creează o partajare nouă la fiecare apel, deci problema rămâne. Fluxul partajat se creează o singură dată, ca proprietate.
  • Scope-ul determină durata de viață. Un scope global ține conexiunea deschisă până la oprirea aplicației.
  • StateFlow aplică conflația și ignoră valorile egale (prin equals) cu cea curentă, deci nu e potrivit pentru evenimente repetate identice.
  • Erorile din amonte opresc partajarea; le tratezi cu catch și retry înainte de stateIn.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre fluxuri reci și calde și a costurilor reale ale fiecăruia. Greșeala cu stateIn apelat la fiecare cerere apare des în code review.

Excepții, interop cu Java și situații practice

92 Junior

Kotlin nu are checked exceptions. Ce înseamnă asta și ce afișează codul de mai jos pentru input = "abc"? Cum anunți apelanții Java că funcția aruncă o excepție?

KOTLIN
val n: Int = try {
    input.toInt()
} catch (e: NumberFormatException) {
    0
} finally {
    println("verificat")
}
println(n)

Răspuns scurt: Afișează verificat și apoi 0. În Kotlin, compilatorul nu te obligă să prinzi sau să declari excepțiile, iar try este o expresie care întoarce valoarea din try sau din catch. Pentru Java, adaugi @Throws(IOException::class) pe funcție.

În Java, excepțiile verificate (checked) ca IOException trebuie fie prinse, fie declarate cu throws. Kotlin a renunțat la această regulă: toate excepțiile se comportă ca cele neverificate. Motivul este că, în practică, regula ducea des la blocuri catch goale sau la împachetări inutile, fără să crească real siguranța.

try este o expresie: valoarea lui este ultima expresie din blocul try sau din catch-ul care a rulat. finally se execută mereu, dar valoarea lui nu contează. Pentru "abc", toInt() aruncă, catch dă 0, finally afișează „verificat”, iar n devine 0.

Lipsa excepțiilor verificate nu înseamnă că le poți ignora. Le documentezi și le tratezi la nivelul potrivit:

KOTLIN
/** @throws IOException dacă fișierul nu poate fi citit */
@Throws(IOException::class)
fun readConfig(path: String): String = File(path).readText()

@Throws contează pentru apelanții Java. Fără ea, metoda nu declară throws IOException, iar compilatorul Java refuză un catch (IOException e) în jurul apelului, pentru că, din punctul lui de vedere, excepția nu poate apărea.

Pentru resurse folosești use, echivalentul lui try-with-resources din Java. Închide resursa și când apare o excepție:

KOTLIN
File("date.txt").bufferedReader().use { reader ->
    println(reader.readLine())
}

În cod de domeniu, pentru erorile așteptate (validare, „utilizator inexistent”), un tip de rezultat (Result sau o clasă sealed) face eroarea vizibilă în semnătură, lucru pe care excepțiile Kotlin nu îl mai fac.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de excepții și a impactului asupra interoperabilității. Candidații veniți din Java nu știu adesea de @Throws și de use.

Eroarea, în practică:NumberFormatException: For input string

93 Junior

Care e diferența dintre require, check și error? Ce excepții aruncă și când o folosești pe fiecare?

Răspuns scurt: require validează argumentele primite și aruncă IllegalArgumentException. check validează starea obiectului sau a programului și aruncă IllegalStateException. error("mesaj") aruncă direct IllegalStateException acolo unde ai ajuns într-o situație imposibilă.

Cele trei funcții exprimă intenția mai clar decât un if urmat de throw și aruncă excepția potrivită:

KOTLIN
class BankAccount(private var balance: Long) {
    var isOpen = true
        private set

    fun withdraw(amount: Long) {
        require(amount > 0) { "Suma trebuie să fie pozitivă, primit: $amount" }
        check(isOpen) { "Contul este închis" }
        check(balance >= amount) { "Fonduri insuficiente: $balance < $amount" }
        balance -= amount
    }

    fun close() { isOpen = false }
}

fun discount(type: String): Int = when (type) {
    "student" -> 50
    "senior" -> 30
    else -> error("Tip de reducere necunoscut: $type")
}
  • require(condiție) { mesaj }: „apelantul mi-a dat date greșite”. Excepția este IllegalArgumentException.
  • check(condiție) { mesaj }: „obiectul nu e într-o stare în care operația are sens”, de exemplu o retragere dintr-un cont închis. Excepția este IllegalStateException.
  • error(mesaj): aruncă IllegalStateException și are tipul Nothing, deci se potrivește în ramuri else sau după Elvis.
  • requireNotNull și checkNotNull: aceleași verificări pentru null, cu smart cast după apel.

Mesajul se dă ca lambda, deci textul (cu interpolare) se construiește doar dacă verificarea eșuează.

Diferența dintre excepții contează pentru cine le tratează: un server poate transforma IllegalArgumentException într-un răspuns HTTP 400 (cerere invalidă), iar IllegalStateException într-o eroare 409 sau 500, după context. Folosite consecvent, aceste funcții documentează contractul funcției direct în cod. Totuși, pentru erori de business așteptate (fonduri insuficiente, într-o aplicație bancară reală), un tip de rezultat explicit poate fi mai potrivit decât o excepție.

Ce urmărește intervievatorul: Verifică dacă știi să validezi intrările și starea în stil idiomatic. Candidații slabi aruncă Exception generic sau folosesc assert.

Eroarea, în practică:IllegalArgumentException: Failed requirement.

94 Junior

Ce fac runCatching și Result în Kotlin? Ce afișează codul de mai jos și ce risc are runCatching în corutine?

KOTLIN
fun parseAge(s: String): Result<Int> =
    runCatching { s.trim().toInt() }
        .mapCatching { require(it in 0..150) { "vârstă imposibilă" }; it }

fun main() {
    println(parseAge(" 42 ").getOrElse { -1 })
    println(parseAge("200").exceptionOrNull()?.message)
    println(parseAge("x").fold({ "vârsta $it" }, { "invalid: ${it::class.simpleName}" }))
}

Răspuns scurt: Afișează 42, vârstă imposibilă și invalid: NumberFormatException. runCatching rulează blocul și întoarce un Result, cu succes sau eroare. Riscul e că prinde orice Throwable, inclusiv CancellationException, și poate ascunde anularea unei corutine.

Result<T> este un tip din biblioteca standard care conține fie o valoare, fie o excepție. runCatching { } execută blocul și împachetează rezultatul. Operațiile pe Result:

  • getOrNull(), getOrElse { }, getOrDefault(x), getOrThrow();
  • exceptionOrNull(), isSuccess, isFailure;
  • map (o excepție aruncată în transformare nu e prinsă), mapCatching (este prinsă), recover, fold;
  • onSuccess { }, onFailure { } pentru efecte secundare.

În exemplu, " 42 " reușește. "200" trece de toInt, dar require din mapCatching eșuează cu mesajul dat. "x" eșuează la toInt cu NumberFormatException.

Limitări de știut:

  • runCatching prinde Throwable, deci și OutOfMemoryError sau StackOverflowError, care de obicei nu trebuie tratate.
  • În corutine, prinde și CancellationException. O corutină anulată poate continua după un runCatching ca și cum nimic nu s-ar fi întâmplat. Verifici cu ensureActive() sau tratezi explicit excepția de anulare.
  • Tipul erorii este mereu Throwable, deci nu știi din semnătură ce erori sunt posibile.

Pentru erori de domeniu cu sens pentru business, o ierarhie sealed e adesea mai expresivă:

KOTLIN
sealed interface AgeResult {
    data class Valid(val age: Int) : AgeResult
    data object NotANumber : AgeResult
    data class OutOfRange(val value: Int) : AgeResult
}

when pe acest tip te obligă să tratezi fiecare caz, iar compilatorul îți spune când apare un caz nou. data object este stabil din Kotlin 1.9.

Ce urmărește intervievatorul: Verifică stăpânirea tratării funcționale a erorilor și cunoașterea limitărilor ei. Riscul cu anularea corutinelor diferențiază candidații care au lucrat cu cod real.

95 Junior

Un coleg nou în echipă, venit din Java, îți spune că nu înțelege corutinele. Cum i le-ai explica?

Răspuns scurt: Pornești de la problema rezolvată (așteptări fără blocarea thread-urilor), dai o analogie simplă, arăți un exemplu scurt de cod secvențial cu suspend, apoi explici cele trei reguli de bază: scope, dispecer și anulare. La final îi verifici înțelegerea printr-un exercițiu mic.

Un model de răspuns structurat:

1. Problema. În Java, un apel de rețea fie blochează un thread, fie te obligă la callback-uri sau CompletableFuture înlănțuite. Thread-urile sunt resurse scumpe, iar callback-urile fac codul greu de citit.

2. Analogia. Un ospătar (thread-ul) nu stă lângă masă cât se gătește comanda. Ia comanda, o trimite la bucătărie, servește alte mese și revine când mâncarea e gata. O corutină „se suspendă” la fel: eliberează thread-ul cât așteaptă și continuă mai târziu, eventual pe alt thread.

3. Exemplul. Cod care arată sincron, dar nu blochează:

KOTLIN
suspend fun showProfile(id: Long) {
    val user = api.loadUser(id)       // suspendare, nu blocare
    val orders = api.loadOrders(id)
    render(user, orders)
}

4. Regulile de bază.

  • Funcțiile suspend se apelează doar din alte funcții suspend sau dintr-un scope (launch, async).
  • Fiecare corutină trăiește într-un scope care o anulează când nu mai e nevoie de ea: concurență structurată.
  • Dispecerul alege thread-urile: IO pentru așteptări, Default pentru calcul.
  • Anularea e cooperativă și se face prin CancellationException, deci nu o înghiți într-un catch general.

5. Verificarea. Îi dau un exercițiu scurt: două apeluri independente, care trebuie făcute în paralel cu async. Îi arăt și o greșeală tipică, Thread.sleep în loc de delay. Rămân disponibil pentru întrebări și îi recomand documentația oficială kotlinlang.org despre corutine.

Ideea de fond: explici de ce înainte de cum, folosești exemple din proiectul echipei și verifici înțelegerea, nu doar transmiți informația.

Ce urmărește intervievatorul: Se verifică înțelegerea conceptelor suficient de bine cât să le explici simplu și capacitatea de a lucra în echipă. Un răspuns bun are structură, nu doar definiții.

96 Mid

Ce sunt platform types (de exemplu String!) și ce risc apare în codul de mai jos?

JAVA
// Java
public class LegacyUserService {
    public String findEmail(long id) { return null; }
}
KOTLIN
val email = LegacyUserService().findEmail(1)
println(email.length)

Răspuns scurt: Pentru valorile venite din Java fără adnotări de nulabilitate, Kotlin nu știe dacă pot fi null și le dă un tip de platformă, String!. Compilatorul permite email.length fără verificare, dar la rulare apare NullPointerException.

Kotlin nu poate deduce nulabilitatea dintr-o metodă Java simplă. Dacă ar trata totul ca nulabil, codul de interoperabilitate ar fi plin de ?. și !!. Dacă ar trata totul ca nenulabil, ar fi nesigur. Compromisul este platform type, notat T! în mesajele compilatorului și în IDE. Nu îl poți scrie tu în cod.

Un tip de platformă poate fi folosit atât ca String, cât și ca String?. Responsabilitatea e a ta:

KOTLIN
val email = LegacyUserService().findEmail(1)       // tip String!
println(email.length)                               // compilează, NPE la rulare

val safe: String? = LegacyUserService().findEmail(1)   // tratezi ca nulabil
println(safe?.length ?: 0)

val strict: String = LegacyUserService().findEmail(1)  // NPE imediat, aici

Cea mai sigură practică este să declari explicit tipul la granița cu Java. Cu String?, compilatorul te obligă să tratezi null. Cu String, Kotlin inserează o verificare chiar la atribuire, deci eroarea apare lângă cauză, nu mai târziu.

Soluția de durată sunt adnotările de nulabilitate în codul Java. Kotlin recunoaște mai multe familii: JetBrains (@Nullable, @NotNull), AndroidX, JSR-305 și JSpecify, standardul comun mai nou. Cu ele, findEmail apare în Kotlin ca String? și nu mai există tip de platformă.

Același lucru apare la colecții: o List<String> din Java devine (Mutable)List<String!>!, adică nu se știe nici dacă lista e mutabilă, nici dacă ea sau elementele pot fi null. Le tratezi la fel: tip explicit și conversie la margine.

Ce urmărește intervievatorul: Verifică înțelegerea punctului slab al null safety în proiecte mixte Java și Kotlin. Candidații care nu știu de platform types sunt surprinși de NPE-uri în cod Kotlin.

Eroarea, în practică:java.lang.NullPointerExceptionNullPointerException: getenv(...) must not be null

97 Mid

Cum faci ca o clasă Kotlin să fie comodă de folosit din Java? Explică @JvmStatic, @JvmField, @JvmOverloads și @JvmName.

Răspuns scurt: @JvmStatic face o metodă din companion object sau object să fie statică reală în Java. @JvmField expune o proprietate direct ca un câmp, fără getter. @JvmOverloads generează supraîncărcări pentru parametrii cu valori implicite, iar @JvmName schimbă numele văzut din Java.

Fără adnotări, codul Kotlin se vede din Java corect, dar uneori incomod:

KOTLIN
// fișierul Logging.kt
@file:JvmName("Logging")

package app

fun logInfo(msg: String) = println("INFO $msg")

class Logger private constructor(val tag: String) {
    companion object {
        @JvmStatic fun create(tag: String) = Logger(tag)
        const val DEFAULT_TAG = "app"
        @JvmField val LEVELS = listOf("INFO", "WARN")
    }

    @JvmOverloads
    fun log(msg: String, level: String = "INFO", withTime: Boolean = false) { /* ... */ }
}

Fiecare adnotare, cu efectul ei în Java:

  • Funcții de nivel superior: ajung într-o clasă numită după fișier (LoggingKt). Cu @file:JvmName("Logging"), apelul din Java devine Logging.logInfo("x").
  • @JvmStatic: fără ea, apelul e Logger.Companion.create("x"); cu ea, Logger.create("x").
  • const val: devine o constantă statică Java, utilizabilă și în adnotări. Funcționează doar pentru primitive și String.
  • @JvmField: Logger.LEVELS e accesat direct, fără getLEVELS(). Nu se poate folosi pe proprietăți private, open sau cu accesori personalizați.
  • @JvmOverloads: generează log(String), log(String, String) și log(String, String, boolean). Fără ea, Java trebuie să dea toți parametrii.
  • @JvmName pe funcții: rezolvă conflictele de semnătură după ștergerea tipurilor, de exemplu fun sum(list: List<Int>) și fun sum(list: List<Double>).
  • @Throws: declară excepțiile verificate pentru Java.

Proprietățile se văd ca getteri și setteri (getTag()), iar cele care încep cu is păstrează numele (isActive()). Într-o bibliotecă folosită și din Java, merită un test scris în Java care verifică API-ul public.

Ce urmărește intervievatorul: Verifică experiența cu proiecte mixte, frecvente în companiile care migrează treptat la Kotlin. Candidații buni știu și limitările fiecărei adnotări.

Eroarea, în practică:Platform declaration clash: same JVM signature

98 Mid

Într-o aplicație Kotlin apar în producție crash-uri NullPointerException, deși codul pare sigur. Cum ai investiga și ai rezolva problema?

Răspuns scurt: Citești stack trace-ul ca să găsești linia și tipul exact al erorii, identifici sursa (!!, tip de platformă din Java, deserializare, ordine de inițializare, lateinit), reproduci problema cu un test, repari la graniță, nu la simptom, apoi cauți tipare similare în restul codului.

Un răspuns structurat, pe pași:

1. Strâng informațiile. Din instrumentul de raportare a erorilor iau stack trace-ul complet, versiunea aplicației, frecvența și eventualii pași comuni ai utilizatorilor. Verific dacă problema a apărut după o anumită versiune: un diff între versiuni restrânge mult căutarea.

2. Citesc mesajul exact. În Kotlin, el spune multe:

  • „Parameter specified as non-null is null”: cod Java sau reflecție a trimis null unui parametru nenulabil;
  • un NPE pe o linie cu !!: o presupunere greșită;
  • UninitializedPropertyAccessException: un lateinit citit prea devreme;
  • un NPE pe o proprietate nenulabilă: deserializare care ocolește constructorul sau o metodă open apelată din constructor.

3. Reproduc cu un test unitar care primește datele problematice, de exemplu răspunsul de la API fără câmpul așteptat. Testul pică înainte de reparație și trece după.

4. Repar cauza, nu simptomul. Un ?. adăugat pe linia care crapă ascunde problema și o mută în altă parte. Mai bine:

  • declar explicit tipurile nulabile la granița cu Java;
  • validez datele externe în DTO-uri și le mapez la modele nenulabile;
  • folosesc o bibliotecă de serializare care respectă constructorii Kotlin;
  • înlocuiesc !! cu requireNotNull și un mesaj clar.

5. Previn. Caut tipare similare în cod (!!, apeluri Java neadnotate), adaug reguli de analiză statică (detekt), adnotări de nulabilitate pe codul Java și monitorizez rata de crash după lansarea reparației.

La final, documentez pe scurt cauza pentru echipă, ca greșeala să nu se repete în alt modul.

Ce urmărește intervievatorul: Se verifică un proces de depanare metodic și înțelegerea surselor reale de NPE în Kotlin. Răspunsul slab este „pun ?. acolo unde crapă”.

Eroarea, în practică:java.lang.NullPointerException

99 Mid

Faci code review unui coleg care scrie Kotlin „ca în Java”. Ce ai observa în codul de mai jos și cum i-ai da feedback?

KOTLIN
fun getActiveNames(users: ArrayList<User>?): ArrayList<String> {
    val result = ArrayList<String>()
    if (users != null) {
        for (i in 0 until users.size) {
            if (users.get(i).isActive == true) {
                result.add(users.get(i).name!!)
            }
        }
    }
    return result
}

Răspuns scurt: Tipuri mutabile concrete în semnătură, listă nulabilă, bucle cu indici, == true și !!. Varianta idiomatică: users.filter { it.isActive }.mapNotNull { it.name }. Feedback-ul îl dai respectuos, explicând de ce și arătând varianta, cu sprijinul uneltelor automate.

Probleme tehnice:

  • ArrayList în semnătură: apelanții sunt obligați să folosească o anumită implementare. List<User> este mai general și read-only.
  • Parametru nulabil: o listă goală exprimă deja „nimic”. Dacă null vine din Java, conversia orEmpty() se face la apel.
  • Bucla cu indici și get(i): e mai lungă și mai ușor de greșit. for (u in users) sau operațiile pe colecții sunt mai clare.
  • == true: are sens doar dacă isActive e Boolean?. Dacă e Boolean, e inutil.
  • !! pe name: crapă dacă un utilizator nu are nume. mapNotNull exprimă explicit decizia de a sări peste ei.

Varianta propusă:

KOTLIN
fun activeNames(users: List<User>): List<String> =
    users.filter { it.isActive }.mapNotNull { it.name }

Cum dai feedback-ul:

1. Separi esențialul de stil. !! este un risc real de crash, iar bucla cu indici este o preferință. Marchezi clar ce e blocant și ce e sugestie. 2. Explici de ce, nu doar ce: „mapNotNull evită crash-ul când lipsește numele” convinge mai mult decât „nu e idiomatic”. 3. Arăți varianta, nu doar critici. 4. Eviți tonul personal: vorbești despre cod, nu despre persoană, și recunoști ce e bine făcut. 5. Propui unelte: inspecțiile IntelliJ, ktlint sau detekt rezolvă automat o parte din observații, iar o discuție de echipă stabilește convențiile o singură dată. 6. Te oferi să discutați pe scurt dacă sunt multe observații, în loc de zeci de comentarii scrise.

Scopul code review-ului este un cod mai bun și un coleg care învață, nu un scor de comentarii.

Ce urmărește intervievatorul: Verifică atât fluența cu Kotlin idiomatic, cât și abilitățile de comunicare în echipă. Un răspuns bun tratează ambele părți.

100 Senior

Echipa ta vrea să migreze un serviciu Java mare la Kotlin. Cum ai planifica migrarea și ce riscuri ai urmări?

Răspuns scurt: Migrare treptată, nu rescriere, pentru că Kotlin și Java coexistă în același modul. Începi cu teste și cod nou, adaugi adnotări de nulabilitate în Java, convertești fișierele pe rând și urmărești Lombok, procesoarele de adnotări, reflecția și timpii de build.

Un plan structurat:

1. Obiective și criterii. Clarific de ce migrăm: siguranță la null, cod mai concis, corutine, atragerea programatorilor. Stabilesc cum măsurăm succesul: incidente legate de null, timpi de build, viteza de livrare. Nu promit cifre înainte de a avea date.

2. Pregătirea. Configurez pluginul Kotlin în build, stabilesc convenții de stil (ktlint, detekt) și organizez o scurtă formare pentru echipă.

3. Ordinea migrării.

  • Teste noi în Kotlin, cu risc mic și beneficiu de învățare.
  • Cod nou în Kotlin, de la o anumită dată.
  • Adnotări de nulabilitate (JSpecify sau JetBrains) în codul Java existent, ca să elimini tipurile de platformă.
  • Conversia fișierelor existente pe rând, începând cu cele cu puține dependențe (modele, utilitare), cu conversia automată din IntelliJ urmată obligatoriu de curățare manuală: !! generate, lateinit, colecții mutabile, companion object-uri.
  • Codul critic abia când echipa e familiarizată.

4. Riscuri tehnice.

  • Lombok: codul Kotlin nu vede ușor metodele generate în același modul. Există un plugin de compatibilitate, dar e mai simplu să convertești clasele Lombok în data class primele.
  • Framework-uri bazate pe reflecție (Spring, JPA, Jackson): ai nevoie de pluginurile kotlin-spring, kotlin-jpa și de modulul Jackson pentru Kotlin.
  • Procesoare de adnotări: kapt e mai lent, deci verifici dacă există variante KSP.
  • API-uri publice folosite din Java: @JvmStatic, @JvmOverloads, @Throws, fără value classes expuse.
  • Timpi de build: îi măsori înainte și după.

5. Siguranță. Fiecare pas e mic, revizuit și acoperit de teste. Nu amesteci conversia cu schimbări de logică în același pull request.

Ce urmărește intervievatorul: La senior se verifică abilitatea de a planifica o schimbare tehnologică cu risc controlat. Răspunsurile slabe propun rescrierea completă sau ignoră interoperabilitatea.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Kotlin, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Kotlin scriind cod, nu doar citind

Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.