Învață Kotlin: comenzi explicate cu exemple

247 de comenzi 38 de categorii

Kotlin este limbajul recomandat de Google pentru aplicații Android și este folosit tot mai mult pe servere. Rulează pe JVM, lângă Java, dar are o sintaxă mai scurtă și protecție la null integrată în tipuri.

Mai jos găsești cuvintele cheie și modificatorii (val, data, sealed, suspend), funcțiile de bază (let, apply, require) și funcțiile pentru colecții, text, fișiere și matematică din biblioteca standard.

Toate exemplele au fost compilate cu kotlinc -Werror și rulate; rezultatul afișat este cel real. Un program Kotlin pornește din funcția fun main().

Bazele programului 6 comenzi

Controlul execuției 8 comenzi

Null safety, tipuri și conversii 4 comenzi

Excepții 2 comenzi

Funcții și lambda 10 comenzi

Generics 3 comenzi

Clase și obiecte 13 comenzi

Moștenire, interfețe și vizibilitate 8 comenzi

Corutine, adnotări și multiplatform 5 comenzi

Afișare și citire de la tastatură 2 comenzi

Scope functions (let, run, with, apply, also) 6 comenzi

Verificări și erori 3 comenzi

Valori utile: lazy, Pair, Triple 3 comenzi

Erori ca valori (Result, runCatching) 3 comenzi

Comparare și timp 6 comenzi

Crearea colecțiilor 9 comenzi

Transformare și parcurgere 9 comenzi

Căutare și verificare 10 comenzi

Calcule pe colecții (sumă, minim, maxim, fold) 8 comenzi

Sortare, ordine și duplicate 6 comenzi

Grupare, împărțire și combinare 8 comenzi

Bucăți din listă și conversii 11 comenzi

Liste și colecții modificabile 7 comenzi

Map-uri (dicționare) 14 comenzi

Tablouri (Array) 7 comenzi

Secvențe (Sequence) 4 comenzi

Text: lungime, verificări și majuscule 7 comenzi

Text: căutare, tăiere și înlocuire 8 comenzi

Text: conversii și formatare 8 comenzi

Text: parcurgere, filtrare și comparare 9 comenzi

Caractere (Char) 3 comenzi

Construirea textului (buildString, StringBuilder) 2 comenzi

Expresii regulate (Regex) 5 comenzi

Fișiere (kotlin.io) 8 comenzi

Matematică (kotlin.math) 8 comenzi

Numere aleatorii (Random) 2 comenzi

Durate și pauze (Duration, Thread.sleep) 3 comenzi

Intervale și conversii de numere 9 comenzi

Toate funcțiile

Lista completă a cuvintelor cheie și a funcțiilor din biblioteca standard Kotlin incluse în această secțiune. Cele cu link au o pagină dedicată.

Cuvinte cheie, modificatori și construcții (78)

Funcție	Ce face
`as`	Conversie de tip: as aruncă excepție dacă tipul nu se potrivește, as? dă null; redenumire la import.
`break`	Oprește imediat bucla curentă (sau bucla cu eticheta dată, break@exterior).
`class`	Declară o clasă: proprietăți în constructorul primar, metode în corp; obiectele se creează fără new.
`continue`	Sare la pasul următor al buclei, peste restul instrucțiunilor din pasul curent.
`do`	Bucla do-while: corpul rulează cel puțin o dată, apoi se repetă cât timp condiția este adevărată.
`else`	Ramura alternativă pentru if și ramura implicită în when.
`false`	Valoarea logică „fals” a tipului Boolean.
`for`	Parcurge elementele unei colecții, ale unui interval sau ale oricărui obiect cu iterator().
`fun`	Declară o funcție, cu parametri tipați, valori implicite, argumente cu nume și corp bloc sau expresie.
`if`	Execută cod după o condiție; în Kotlin if este și expresie care returnează o valoare.
`in`	Verifică apartenența (x in lista), parcurge în for și marchează contravarianța (in T).
`interface`	Contract cu metode și proprietăți, eventual cu implementări implicite; o clasă poate implementa mai multe.
`is`	Verifică tipul unei valori la rulare și face smart cast în ramura adevărată.
`null`	Lipsa unei valori; poate fi pusă doar în variabile cu tip nullable (String?).
`object`	Declară un singleton (un singur obiect) sau creează pe loc un obiect anonim.
`package`	Stabilește pachetul fișierului; import aduce în fișier clase și funcții din alte pachete.
`return`	Iese din funcție și dă înapoi o valoare; return@eticheta iese doar dintr-o lambda.
`super`	Apelează versiunea din clasa de bază sau din interfață a unei metode suprascrise.
`this`	Obiectul curent sau receptorul unei extensii; this@Nume ajunge la un obiect exterior.
`throw`	Aruncă o excepție; este expresie de tip Nothing, deci poate sta după ?: sau în when.
`true`	Valoarea logică „adevărat” a tipului Boolean.
`try`	Prinde excepțiile cu catch și rulează finally; în Kotlin try este și expresie.
`typealias`	Dă un nume nou, mai scurt, unui tip existent (tip funcție, generic lung).
`val`	Declară o variabilă care nu mai poate primi altă valoare după inițializare.
`var`	Declară o variabilă a cărei valoare poate fi schimbată.
`when`	Alege o ramură după valoare, tip sau condiție; înlocuiește switch și poate returna o valoare.
`while`	Repetă un bloc cât timp condiția este adevărată.
`by`	Delegă implementarea unei interfețe altui obiect sau citirea unei proprietăți unui delegat.
`catch`	Blocul care tratează o excepție de un anumit tip aruncată în try.
`constructor`	Declară un constructor secundar (care apelează this(…)) sau unul primar cu modificatori.
`finally`	Bloc care rulează la ieșirea din try, indiferent dacă a apărut o excepție.
`get și set`	Getteri și setteri personalizați pentru proprietăți; field este valoarea păstrată.
`import`	Aduce în fișier o clasă sau funcție din alt pachet, eventual cu alt nume (as).
`init`	Bloc de cod care rulează la crearea fiecărui obiect, în ordinea din clasă.
`value class`	Învelește o singură valoare într-un tip nou, verificat la compilare, fără obiect în plus la rulare.
`where`	Adaugă mai multe restricții (limite superioare) pe un parametru de tip generic.
`abstract`	Clasă care nu poate fi creată direct și membri fără corp, implementați de subclase.
`annotation`	Declară o adnotare proprie (@Nume), cu @Target și parametri constanți.
`companion`	Obiect din interiorul unei clase care ține membrii comuni (în locul lui static din Java).
`const`	Constantă cunoscută la compilare (primitive sau String), la nivelul de sus sau într-un object.
`crossinline`	Parametru lambda al unei funcții inline apelat din alt context; interzice return simplu în el.
`data`	Clasă pentru date cu toString, equals, hashCode, copy și componentN generate automat.
`enum`	Tip cu un set fix de valori numite, care pot avea proprietăți și metode; entries le listează.
`external`	Funcție implementată în afara lui Kotlin: cod nativ prin JNI sau JavaScript în Kotlin/JS.
`final`	Interzice moștenirea sau suprascrierea; implicit în Kotlin, util ca final override.
`infix`	Permite apelul fără punct și paranteze al unei funcții cu un parametru: a to b.
`inline`	Copiază corpul funcției și lambda-urile ei în locul apelului; permite return din lambda.
`inner`	Clasă interioară care ține o referință la obiectul exterior și îi folosește membrii.
`internal`	Vizibilitate în tot modulul (proiect Gradle, comandă kotlinc), dar nu în afara lui.
`lateinit`	Proprietate var ne-nullable care primește valoare după crearea obiectului.
`noinline`	Parametru lambda al unei funcții inline care nu se copiază, ca să poată fi păstrat.
`open`	Permite moștenirea unei clase sau suprascrierea unei metode (implicit sunt final).
`operator`	Leagă o funcție cu nume special (plus, get, contains…) de operatorul ei (+, [], in).
`out și in (varianță)`	out T doar produce valori (covariant), in T doar le consumă (contravariant).
`override`	Înlocuiește o metodă sau proprietate moștenită dintr-o clasă open sau dintr-o interfață.
`private`	Vizibil doar în clasa respectivă sau, la nivelul de sus, doar în fișier.
`protected`	Vizibil în clasă și în subclasele ei, nu și din exterior.
`public`	Vizibil peste tot; este vizibilitatea implicită în Kotlin.
`reified`	Păstrează tipul generic T la rulare într-o funcție inline: x is T, T::class.
`sealed`	Ierarhie închisă de subtipuri cunoscute la compilare; when le verifică pe toate fără else.
`suspend`	Funcție care se poate suspenda fără să blocheze firul; se apelează din corutine.
`tailrec`	Transformă recursivitatea de coadă într-o buclă, fără StackOverflowError.
`vararg`	Parametru care primește oricâte argumente; un tablou se trimite cu operatorul spread *.
`expect și actual`	Declarație comună în Kotlin Multiplatform, implementată separat pe fiecare platformă.
`ținte de adnotare (field, file, param...)`	@field:, @get:, @param:, @file: aleg unde ajunge exact o adnotare în bytecode.
`main`	Funcția de pornire a programului: fun main() sau fun main(args: Array<String>).
`null safety (?. ?: !!)`	Tipuri nullable și operatorii ?. (apel sigur), ?: (valoare implicită), !! (forțare).
`smart cast`	După o verificare cu is sau != null, compilatorul tratează automat variabila ca tipul verificat.
`string templates`	Valori puse direct în text cu $nume și ${expresie}.
`range-uri (.., until, downTo, step)`	Intervale de numere sau caractere: 1..10, 0 until n, 10 downTo 1 step 2.
`lambda`	Funcție fără nume între acolade, { x -> x * 2 }; it este parametrul unic implicit.
`funcții de extensie`	Adaugă metode noi unui tip existent (String, Int, List) fără să modifici clasa.
`funcții de ordin superior`	Funcții care primesc sau returnează alte funcții; referințe cu ::.
`destructuring`	Desface un obiect în mai multe variabile: val (nume, nota) = pereche.
`proprietăți delegate`	Proprietăți care lasă un delegat să decidă citirea și scrierea: by lazy, observable, map.
`generics`	Clase și funcții cu parametri de tip (<T>), verificate la compilare, cu limite superioare.
`corutine (ideea)`	Calcule care se pot suspenda și relua: sequence { yield } în stdlib, kotlinx.coroutines pentru async.
`kotlinc`	Compilatorul Kotlin din linia de comandă: kotlinc main.kt -include-runtime -d program.jar.

Funcții de bază, scope functions și erori (40)

Funcție	Ce face
`println`	Afișează o valoare și trece la rând nou; println() fără argument afișează un rând gol.
`print`	Afișează o valoare fără să treacă la rând nou.
`readln`	Citește un rând de la tastatură ca String; aruncă excepție la sfârșitul intrării.
`readlnOrNull`	Citește un rând de la tastatură sau returnează null când intrarea s-a terminat.
`let`	Rulează un bloc cu obiectul ca it și returnează rezultatul blocului; des folosit cu ?. pentru null.
`run`	Rulează un bloc cu obiectul ca this și returnează rezultatul blocului.
`with`	Ca run, dar obiectul se dă ca argument: with(obiect) { … }.
`apply`	Configurează un obiect în bloc (this) și returnează obiectul însuși.
`also`	Rulează o acțiune suplimentară cu obiectul (it) și returnează obiectul neschimbat.
`takeIf`	Returnează obiectul dacă respectă condiția, altfel null.
`takeUnless`	Returnează obiectul dacă NU respectă condiția, altfel null.
`repeat`	Rulează un bloc de un număr dat de ori, cu indexul curent ca it.
`require`	Verifică un argument; dacă condiția e falsă aruncă IllegalArgumentException.
`requireNotNull`	Verifică faptul că un argument nu e null și îl returnează ca tip non-null.
`check`	Verifică starea programului; dacă condiția e falsă aruncă IllegalStateException.
`checkNotNull`	Verifică faptul că o valoare de stare nu e null și o returnează ca tip non-null.
`error`	Aruncă imediat IllegalStateException cu mesajul dat; tipul returnat este Nothing.
`TODO`	Marchează cod nescris încă; la rulare aruncă NotImplementedError.
`lazy`	Creează o valoare calculată abia la prima folosire, apoi reținută (val x by lazy { … }).
`to`	Funcție infix care creează o pereche: „Iași” to 5 este Pair(„Iași”, 5).
`Pair`	Clasă data cu două valori, first și second, care se pot destructura.
`Triple`	Clasă data cu trei valori, first, second și third.
`runCatching`	Rulează un bloc și prinde excepția într-un Result, în loc să o arunce.
`Result.getOrNull`	Returnează valoarea din Result sau null dacă a apărut o eroare.
`Result.getOrElse`	Returnează valoarea din Result sau rezultatul unui bloc care primește excepția.
`Result.getOrThrow`	Returnează valoarea din Result sau aruncă din nou excepția prinsă.
`Result.onSuccess`	Rulează o acțiune doar dacă Result conține o valoare; returnează Result-ul.
`Result.onFailure`	Rulează o acțiune doar dacă Result conține o eroare; returnează Result-ul.
`Result.map`	Transformă valoarea dintr-un Result reușit; eroarea trece neschimbată.
`Result.fold`	Tratează ambele cazuri dintr-un Result cu câte un bloc și returnează un singur rezultat.
`maxOf`	Returnează cea mai mare dintre două sau mai multe valori.
`minOf`	Returnează cea mai mică dintre două sau mai multe valori.
`Any.toString`	Transformă un obiect în text; println și string templates îl apelează automat.
`Any.hashCode`	Returnează un număr folosit de HashMap și HashSet; trebuie să fie egal pentru obiecte egale.
`Comparable.compareTo`	Compară două obiecte: număr negativ, zero sau pozitiv; stă în spatele lui <, >, sorted().
`compareBy`	Construiește un Comparator după una sau mai multe proprietăți, pentru sortare.
`compareValues`	Compară două valori Comparable care pot fi null (null este cel mai mic).
`measureTimeMillis`	Rulează un bloc și returnează durata lui în milisecunde (Long).
`measureTime`	Rulează un bloc și returnează durata lui ca Duration.
`use`	Folosește o resursă (fișier, stream) și o închide automat la final, chiar și la excepție.

Colecții (169)

Funcție	Ce face
`listOf`	Creează o listă doar pentru citire din elementele date.
`mutableListOf`	Creează o listă modificabilă (MutableList), în care poți adăuga și șterge elemente.
`arrayListOf`	Creează un ArrayList modificabil din elementele date.
`emptyList`	Întoarce o listă goală, doar pentru citire, de tipul cerut.
`listOfNotNull`	Creează o listă din elementele date, sărind peste valorile null.
`mapOf`	Creează un map doar pentru citire din perechi cheie to valoare, cu ordinea păstrată.
`mutableMapOf`	Creează un map modificabil (LinkedHashMap) din perechi cheie to valoare.
`hashMapOf`	Creează un HashMap modificabil; ordinea cheilor nu este garantată.
`linkedMapOf`	Creează un LinkedHashMap modificabil, care păstrează ordinea de inserare.
`sortedMapOf`	Creează un map modificabil (TreeMap) cu cheile mereu în ordine crescătoare.
`emptyMap`	Întoarce un map gol, doar pentru citire.
`setOf`	Creează o mulțime doar pentru citire, fără duplicate, cu ordinea primei apariții.
`mutableSetOf`	Creează o mulțime modificabilă (LinkedHashSet) din elementele date.
`hashSetOf`	Creează un HashSet modificabil; ordinea elementelor nu este garantată.
`sortedSetOf`	Creează o mulțime modificabilă (TreeSet) cu elementele mereu sortate.
`emptySet`	Întoarce o mulțime goală, doar pentru citire.
`arrayOf`	Creează un tablou (Array) de lungime fixă din elementele date.
`intArrayOf`	Creează un IntArray, un tablou de Int primitive, din valorile date.
`emptyArray`	Întoarce un tablou gol de tipul cerut.
`arrayOfNulls`	Creează un tablou de lungimea dată, cu toate pozițiile null.
`buildList`	Construiește o listă doar pentru citire adăugând elemente într-un bloc de cod.
`buildMap`	Construiește un map doar pentru citire punând intrări într-un bloc de cod.
`buildSet`	Construiește o mulțime doar pentru citire adăugând elemente într-un bloc de cod.
`List`	Interfața listei doar pentru citire: elemente ordonate, accesate după poziție.
`Iterable.map`	Creează o listă nouă aplicând o funcție fiecărui element.
`Iterable.mapNotNull`	Ca map, dar sare peste rezultatele null.
`Iterable.mapIndexed`	Ca map, dar funcția primește și poziția fiecărui element.
`Iterable.filter`	Păstrează într-o listă nouă doar elementele care îndeplinesc condiția.
`Iterable.filterNot`	Păstrează doar elementele care NU îndeplinesc condiția.
`Iterable.filterNotNull`	Întoarce o listă fără valorile null, cu tip non-null.
`Iterable.filterIsInstance`	Păstrează doar elementele de un anumit tip, deja convertite la acel tip.
`Iterable.filterIndexed`	Filtrează elementele cu o condiție care primește și poziția.
`Iterable.forEach`	Execută o acțiune pentru fiecare element, în ordine.
`Iterable.forEachIndexed`	Execută o acțiune pentru fiecare element, primind și poziția lui.
`Iterable.onEach`	Execută o acțiune pe fiecare element și întoarce colecția, pentru lanțuri.
`Iterable.first`	Întoarce primul element (sau primul care îndeplinește condiția); excepție dacă nu există.
`Iterable.firstOrNull`	Întoarce primul element (sau primul potrivit) ori null dacă nu există.
`List.last`	Întoarce ultimul element (sau ultimul potrivit); excepție dacă nu există.
`List.lastOrNull`	Întoarce ultimul element (sau ultimul potrivit) ori null.
`Iterable.find`	Întoarce primul element care îndeplinește condiția sau null.
`Iterable.single`	Întoarce singurul element (potrivit); excepție dacă sunt zero sau mai multe.
`Iterable.any`	Verifică dacă măcar un element îndeplinește condiția (sau dacă există elemente).
`Iterable.all`	Verifică dacă toate elementele îndeplinesc condiția.
`Iterable.none`	Verifică dacă niciun element nu îndeplinește condiția.
`Iterable.count`	Numără elementele sau doar pe cele care îndeplinesc o condiție.
`Iterable.sum`	Adună toate numerele din colecție.
`Iterable.sumOf`	Adună valoarea calculată de o funcție pentru fiecare element.
`Iterable.average`	Calculează media aritmetică a numerelor, ca Double (NaN pentru colecție goală).
`Iterable.max`	Întoarce cel mai mare element; excepție pe o colecție goală.
`Iterable.maxOrNull`	Întoarce cel mai mare element sau null pentru o colecție goală.
`Iterable.min`	Întoarce cel mai mic element; excepție pe o colecție goală.
`Iterable.minOrNull`	Întoarce cel mai mic element sau null pentru o colecție goală.
`Iterable.maxBy`	Întoarce elementul cu valoarea maximă a funcției date; excepție dacă e gol.
`Iterable.maxByOrNull`	Întoarce elementul cu valoarea maximă a funcției date sau null.
`Iterable.minBy`	Întoarce elementul cu valoarea minimă a funcției date; excepție dacă e gol.
`Iterable.minByOrNull`	Întoarce elementul cu valoarea minimă a funcției date sau null.
`Iterable.sorted`	Întoarce o listă nouă sortată crescător.
`Iterable.sortedDescending`	Întoarce o listă nouă sortată descrescător.
`Iterable.sortedBy`	Întoarce o listă nouă sortată crescător după o cheie calculată.
`Iterable.sortedByDescending`	Întoarce o listă nouă sortată descrescător după o cheie calculată.
`Iterable.sortedWith`	Întoarce o listă nouă sortată după un Comparator (mai multe criterii, Collator).
`Iterable.reversed`	Întoarce o listă nouă cu elementele în ordine inversă.
`Iterable.shuffled`	Întoarce o listă nouă cu elementele amestecate aleatoriu.
`Iterable.distinct`	Întoarce o listă fără duplicate, în ordinea primei apariții.
`Iterable.distinctBy`	Elimină elementele care au aceeași cheie calculată, păstrându-l pe primul.
`Iterable.groupBy`	Grupează elementele după o cheie într-un Map<cheie, List<element>>.
`Iterable.groupingBy`	Pregătește o grupare după cheie, pentru eachCount, fold sau reduce pe grupe.
`Grouping.eachCount`	Numără câte elemente are fiecare cheie a unei grupări.
`Iterable.associate`	Construiește un map din perechile cheie to valoare întoarse pentru fiecare element.
`Iterable.associateBy`	Construiește un map cu elementele ca valori și o cheie calculată.
`Iterable.associateWith`	Construiește un map cu elementele ca chei și o valoare calculată.
`Iterable.partition`	Împarte elementele în două liste: care îndeplinesc condiția și care nu.
`Iterable.chunked`	Împarte colecția în bucăți consecutive de câte n elemente.
`Iterable.windowed`	Întoarce ferestre glisante de câte n elemente consecutive.
`Iterable.zip`	Formează perechi din elementele de pe aceeași poziție a două colecții.
`Iterable.unzip`	Desparte o listă de perechi în două liste.
`Iterable.flatten`	Transformă o colecție de colecții într-o singură listă.
`Iterable.flatMap`	Aplică o funcție care întoarce o colecție și lipește toate rezultatele.
`Iterable.fold`	Combină elementele pe rând într-un acumulator, pornind de la o valoare inițială.
`Iterable.foldIndexed`	Ca fold, dar funcția primește și poziția elementului.
`Iterable.reduce`	Combină elementele pe rând, pornind de la primul; excepție pe colecție goală.
`Iterable.runningFold`	Ca fold, dar întoarce lista cu toate valorile intermediare.
`Iterable.scan`	Același lucru ca runningFold: lista valorilor intermediare ale acumulatorului.
`Iterable.take`	Întoarce primele n elemente.
`Iterable.drop`	Întoarce elementele rămase după ce sare peste primele n.
`Iterable.takeWhile`	Ia elementele de la început cât timp condiția este adevărată.
`Iterable.dropWhile`	Sare elementele de la început cât timp condiția este adevărată și întoarce restul.
`List.takeLast`	Întoarce ultimele n elemente ale listei.
`List.dropLast`	Întoarce lista fără ultimele n elemente.
`Iterable.joinToString`	Unește elementele într-un text, cu separator, prefix, sufix și transformare.
`Iterable.toList`	Copiază elementele într-o listă nouă, doar pentru citire.
`Iterable.toMutableList`	Copiază elementele într-o listă nouă, modificabilă.
`Iterable.toSet`	Copiază elementele într-o mulțime, fără duplicate.
`Iterable.toMutableSet`	Copiază elementele într-o mulțime modificabilă.
`Iterable.toSortedSet`	Copiază elementele într-o mulțime sortată (TreeSet).
`Iterable.toMap`	Transformă o colecție de perechi într-un map.
`Iterable.contains`	Verifică dacă un element există în colecție (operatorul in).
`Iterable.indexOf`	Întoarce poziția primei apariții a unui element sau -1.
`Iterable.plus`	Operatorul +: o listă nouă cu elementul sau colecția adăugate.
`Iterable.minus`	Operatorul -: o listă nouă fără elementul (prima apariție) sau fără colecția dată.
`List.getOrElse`	Întoarce elementul de pe poziție sau valoarea calculată de lambda dacă poziția nu există.
`List.getOrNull`	Întoarce elementul de pe poziție sau null dacă poziția nu există.
`Iterable.withIndex`	Parcurge elementele împreună cu pozițiile lor (index, value).
`Iterable.asSequence`	Transformă colecția într-o secvență leneșă, procesată element cu element.
`List.slice`	Întoarce elementele de pe pozițiile date (interval inclusiv sau listă de indici).
`List.subList`	Întoarce o vedere asupra porțiunii [deLa, panaLa) din listă.
`Iterable.union`	Reuniunea a două colecții, ca mulțime fără duplicate.
`Iterable.intersect`	Elementele comune ale două colecții, ca mulțime.
`Iterable.subtract`	Elementele din prima colecție care nu sunt în a doua, ca mulțime.
`Collection.random`	Alege un element la întâmplare (opțional cu un Random dat).
`Collection.isEmpty`	Verifică dacă colecția nu are niciun element.
`Collection.isNotEmpty`	Verifică dacă colecția are cel puțin un element.
`Collection.orEmpty`	Întoarce colecția sau o colecție goală dacă este null.
`Collection.ifEmpty`	Întoarce colecția sau rezultatul unei lambda dacă este goală.
`List.indices`	Intervalul pozițiilor valide ale listei (0..size-1).
`List.lastIndex`	Poziția ultimului element (size – 1), sau -1 pentru o listă goală.
`List.binarySearch`	Caută rapid un element într-o listă sortată; întoarce poziția sau o valoare negativă.
`Iterable.elementAt`	Întoarce elementul de pe o poziție, pentru orice colecție.
`Iterable.firstNotNullOf`	Aplică funcția pe rând și întoarce primul rezultat care nu este null.
`MutableList.add`	Adaugă un element la final sau la o poziție dată.
`MutableList.remove`	Șterge prima apariție a unei valori; întoarce true dacă a găsit-o.
`MutableList.removeAt`	Șterge elementul de pe o poziție și îl întoarce.
`MutableCollection.removeAll`	Șterge pe loc toate elementele care îndeplinesc condiția sau apar în altă colecție.
`MutableCollection.retainAll`	Păstrează pe loc doar elementele care îndeplinesc condiția sau apar în altă colecție.
`MutableCollection.addAll`	Adaugă toate elementele altei colecții.
`MutableList.sort`	Sortează lista pe loc, crescător.
`MutableList.sortBy`	Sortează lista pe loc după o cheie calculată.
`MutableList.sortDescending`	Sortează lista pe loc, descrescător.
`MutableList.shuffle`	Amestecă pe loc elementele listei.
`MutableList.clear`	Șterge toate elementele listei.
`MutableList.removeFirst`	Scoate și întoarce primul element; excepție pe o listă goală.
`MutableList.removeLast`	Scoate și întoarce ultimul element; excepție pe o listă goală.
`MutableList.fill`	Pune aceeași valoare pe toate pozițiile listei.
`MutableList.removeIf`	Șterge pe loc elementele care îndeplinesc condiția (funcție din Java).
`Map.getValue`	Întoarce valoarea cheii, non-null; NoSuchElementException dacă cheia lipsește.
`Map.getOrDefault`	Întoarce valoarea cheii sau valoarea implicită dată.
`Map.getOrElse`	Întoarce valoarea cheii sau rezultatul lambdei dacă lipsește.
`MutableMap.getOrPut`	Întoarce valoarea cheii; dacă lipsește, o calculează, o salvează și o întoarce.
`Map.filterKeys`	Map nou doar cu intrările ale căror chei îndeplinesc condiția.
`Map.filterValues`	Map nou doar cu intrările ale căror valori îndeplinesc condiția.
`Map.mapValues`	Map nou cu aceleași chei și valori transformate.
`Map.mapKeys`	Map nou cu aceleași valori și chei transformate.
`Map.toSortedMap`	Copiază map-ul într-un SortedMap, cu cheile ordonate.
`Map.forEach`	Execută o acțiune pentru fiecare intrare (cheie, valoare).
`Map.keys`	Mulțimea cheilor map-ului.
`Map.values`	Colecția valorilor map-ului (pot exista repetări).
`Map.entries`	Mulțimea intrărilor map-ului, fiecare cu key și value.
`Map.containsKey`	Verifică dacă map-ul are cheia dată (operatorul in).
`Map.containsValue`	Verifică dacă map-ul are valoarea dată.
`MutableMap.put`	Pune o valoare la o cheie (map[k] = v) și întoarce valoarea veche sau null.
`MutableMap.remove`	Șterge o cheie și întoarce valoarea ei sau null.
`MutableMap.putAll`	Copiază în map toate intrările altui map.
`Map.plus`	Operatorul +: map nou cu intrările adăugate; la chei comune câștigă dreapta.
`Map.minus`	Operatorul -: map nou fără cheia sau cheile date.
`Map.toList`	Transformă map-ul într-o listă de perechi (cheie, valoare).
`Map.maxByOrNull`	Întoarce intrarea cu valoarea maximă a funcției date sau null.
`MutableMap.merge`	Pune valoarea sau o combină cu cea existentă printr-o funcție (din Java).
`Array.size`	Numărul de elemente ale tabloului, fix de la creare.
`Array.toList`	Copiază elementele tabloului într-o listă.
`Array.sort`	Sortează tabloul pe loc, crescător.
`Array.contentToString`	Textul cu elementele tabloului, de forma [1, 2, 3].
`Array.contentEquals`	Verifică dacă două tablouri au aceleași elemente în aceeași ordine.
`Array.copyOf`	Întoarce o copie a tabloului, opțional cu altă lungime.
`Array.indices`	Intervalul pozițiilor valide ale tabloului.
`Array.sum`	Adună toate numerele din tablou.
`sequenceOf`	Creează o secvență leneșă din elementele date.
`generateSequence`	Creează o secvență (posibil infinită) dintr-o valoare inițială și o funcție de pas.
`sequence`	Construiește o secvență cu yield într-un bloc de cod, element cu element.
`Sequence.toList`	Calculează toate elementele secvenței și le pune într-o listă.

Text, caractere și expresii regulate (88)

Funcție	Ce face
`String.length`	Numărul de caractere din text (proprietate, fără paranteze).
`String.isEmpty`	true dacă textul nu are niciun caracter („”).
`String.isBlank`	true dacă textul este gol sau conține doar spații albe.
`String.isNotBlank`	true dacă textul are cel puțin un caracter care nu este spațiu.
`String.trim`	Elimină spațiile albe de la începutul și de la sfârșitul textului.
`String.trimStart`	Elimină spațiile albe (sau caracterele date) doar de la început.
`String.trimEnd`	Elimină spațiile albe (sau caracterele date) doar de la final.
`String.uppercase`	Returnează textul cu toate literele mari, independent de limba sistemului.
`String.lowercase`	Returnează textul cu toate literele mici.
`String.replaceFirstChar`	Înlocuiește primul caracter; replaceFirstChar { it.uppercase() } face prima literă mare.
`String.split`	Împarte textul după unul sau mai mulți separatori (sau un Regex) într-o listă.
`String.lines`	Împarte textul în rânduri, recunoscând \n, \r\n și \r.
`String.substring`	Bucata de text dintre două poziții (start inclus, end exclus).
`String.substringBefore`	Partea de text dinaintea primei apariții a unui separator.
`String.substringAfter`	Partea de text de după prima apariție a unui separator.
`String.substringAfterLast`	Partea de text de după ultima apariție a unui separator (ex. extensia).
`String.replace`	Înlocuiește toate aparițiile unui text, caracter sau tipar Regex.
`String.startsWith`	Verifică dacă textul începe cu un prefix dat.
`String.endsWith`	Verifică dacă textul se termină cu un sufix dat.
`String.contains`	Verifică dacă textul conține alt text, un caracter sau un Regex (operatorul in).
`String.indexOf`	Poziția primei apariții a unui text sau caracter, sau -1.
`String.lastIndexOf`	Poziția ultimei apariții a unui text sau caracter, sau -1.
`String.padStart`	Completează textul la stânga până la o lungime dată (ex. zerouri în față).
`String.padEnd`	Completează textul la dreapta până la o lungime dată.
`String.repeat`	Construiește un text din n copii ale textului.
`String.reversed`	Returnează textul cu caracterele în ordine inversă.
`String.toInt`	Transformă textul în Int; aruncă NumberFormatException dacă nu e număr.
`String.toIntOrNull`	Transformă textul în Int sau returnează null dacă nu e număr valid.
`String.toDouble`	Transformă textul în Double (cu punct zecimal).
`String.toDoubleOrNull`	Transformă textul în Double sau returnează null dacă nu e număr valid.
`String.toLong`	Transformă textul într-un număr Long, pentru valori mari.
`String.toBoolean`	true doar pentru textul „true” (fără să conteze literele mari); altfel false.
`String.format`	Formatează valori după un șablon cu %d, %s, %.2f (java.util.Formatter).
`String.removePrefix`	Elimină un prefix de la început, doar dacă există.
`String.removeSuffix`	Elimină un sufix de la final, doar dacă există.
`String.removeSurrounding`	Elimină un prefix și un sufix (ex. ghilimele) doar dacă sunt la ambele capete.
`String.filter`	Păstrează doar caracterele care respectă o condiție și returnează un String.
`String.count`	Numărul de caractere, total sau doar cele care respectă o condiție.
`String.chunked`	Împarte textul în bucăți consecutive de lungime fixă.
`String.windowed`	Ferestre de caractere care se pot suprapune, cu pas configurabil.
`String.first`	Primul caracter al textului sau primul care respectă o condiție.
`String.last`	Ultimul caracter al textului sau ultimul care respectă o condiție.
`String.take`	Primele n caractere, fără excepție dacă textul e mai scurt.
`String.drop`	Textul fără primele n caractere.
`String.takeLast`	Ultimele n caractere ale textului.
`String.all`	true dacă toate caracterele respectă condiția (și pentru textul gol).
`String.any`	true dacă măcar un caracter respectă condiția.
`String.equals`	Compară două texte; cu ignoreCase = true nu contează literele mari.
`String.compareTo`	Compară alfabetic (după codul caracterelor): negativ, 0 sau pozitiv.
`String.toCharArray`	Copiază caracterele într-un CharArray modificabil.
`String.trimIndent`	Elimină indentarea comună dintr-un raw string pe mai multe rânduri.
`String.trimMargin`	Elimină tot până la marcajul \| de pe fiecare rând al unui raw string.
`String.toRegex`	Creează un Regex din text.
`String.matches`	true dacă tot textul se potrivește cu un Regex (infix: text matches regex).
`String.ifBlank`	Returnează textul sau o valoare implicită dacă e gol ori doar cu spații.
`String.orEmpty`	Transformă un String? null în textul gol „”.
`String.encodeToByteArray`	Octeții textului în codificarea UTF-8.
`String.toByteArray`	Octeții textului într-o codificare dată (implicit UTF-8), pe JVM.
`String.get`	Caracterul de la o poziție: text[i] sau text.get(i).
`String.plus`	Lipește două texte (operatorul +); partea din dreapta poate fi de orice tip.
`String.commonPrefixWith`	Cel mai lung început comun al două texte.
`Char.isDigit`	true dacă caracterul este cifră.
`Char.isLetter`	true dacă caracterul este literă (inclusiv cu diacritice).
`Char.isLetterOrDigit`	true dacă caracterul este literă sau cifră.
`Char.isWhitespace`	true pentru spații, tab-uri și rânduri noi.
`Char.isUpperCase`	true dacă caracterul este literă mare.
`Char.isLowerCase`	true dacă caracterul este literă mică.
`Char.uppercaseChar`	Varianta cu literă mare a caracterului, ca Char.
`Char.lowercaseChar`	Varianta cu literă mică a caracterului, ca Char.
`Char.digitToInt`	Valoarea numerică a unei cifre: ‘7’.digitToInt() este 7.
`Char.code`	Codul Unicode al caracterului: ‘A’.code este 65.
`buildString`	Construiește un String cu append/appendLine într-un StringBuilder.
`StringBuilder.append`	Adaugă o valoare la finalul textului în construcție.
`StringBuilder.appendLine`	Adaugă o valoare urmată de rând nou.
`StringBuilder.insert`	Inserează o valoare la o poziție dată.
`StringBuilder.reverse`	Inversează pe loc caracterele din builder.
`StringBuilder.deleteCharAt`	Șterge caracterul de la o poziție dată.
`StringBuilder.clear`	Golește builder-ul ca să poată fi refolosit.
`Regex`	O expresie regulată (tipar de text), creată cu Regex(„…”).
`Regex.find`	Prima potrivire a tiparului în text, ca MatchResult sau null.
`Regex.findAll`	Toate potrivirile tiparului, ca Sequence<MatchResult>.
`Regex.matches`	true dacă tot textul se potrivește cu tiparul.
`Regex.containsMatchIn`	true dacă tiparul apare undeva în text.
`Regex.replace`	Înlocuiește potrivirile cu un text ($1 pentru grupuri) sau cu rezultatul unei lambda.
`Regex.split`	Împarte textul în bucăți la fiecare potrivire a tiparului.
`MatchResult.groupValues`	Lista textelor prinse: 0 este toată potrivirea, 1, 2… grupurile.
`MatchResult.destructured`	Pune grupurile unei potriviri direct în variabile: val (a, b) = m.destructured.
`MatchResult.value`	Textul găsit de potrivire.

Fișiere, matematică, numere aleatorii, timp și range-uri (66)

Funcție	Ce face
`File.readText`	Citește tot conținutul unui fișier ca String (implicit UTF-8).
`File.writeText`	Scrie un text în fișier, înlocuind tot conținutul anterior.
`File.appendText`	Adaugă un text la finalul fișierului.
`File.readLines`	Citește fișierul ca listă de rânduri.
`File.forEachLine`	Rulează un bloc pentru fiecare rând, fără să încarce tot fișierul în memorie.
`File.useLines`	Dă rândurile fișierului ca Sequence într-un bloc și închide fișierul la final.
`File.walk`	Parcurge un director cu toate subdirectoarele și fișierele lui.
`File.bufferedReader`	Deschide fișierul pentru citire cu buffer (folosit cu use).
`File.bufferedWriter`	Deschide fișierul pentru scriere cu buffer (folosit cu use).
`File.readBytes`	Citește tot fișierul ca ByteArray, pentru date binare.
`File.writeBytes`	Scrie un ByteArray în fișier, înlocuind conținutul.
`File.copyTo`	Copiază un fișier; aruncă excepție dacă destinația există, fără overwrite = true.
`File.deleteRecursively`	Șterge definitiv un fișier sau un director cu tot conținutul.
`File.extension`	Extensia din numele fișierului, după ultimul punct (fără punct).
`File.nameWithoutExtension`	Numele fișierului fără extensie.
`abs`	Valoarea absolută a unui număr (kotlin.math).
`sqrt`	Rădăcina pătrată a unui Double.
`pow`	Ridicare la putere: 2.0.pow(10) este 1024.0.
`max`	Cel mai mare dintre două numere de același tip (kotlin.math).
`min`	Cel mai mic dintre două numere de același tip (kotlin.math).
`round`	Rotunjește la cel mai apropiat întreg (Double); la jumătate alege numărul par.
`roundToInt`	Rotunjește un Double la Int; jumătățile se rotunjesc în sus.
`floor`	Rotunjește în jos, spre minus infinit.
`ceil`	Rotunjește în sus, spre plus infinit.
`truncate`	Taie zecimalele, rotunjind spre zero.
`PI`	Constanta π (3.141592653589793).
`E`	Constanta e, baza logaritmului natural (2.718281828459045).
`sign`	Semnul unui număr: -1, 0 sau 1.
`ln`	Logaritmul natural (baza e).
`log10`	Logaritmul în baza 10.
`log2`	Logaritmul în baza 2.
`sin`	Sinusul unui unghi dat în radiani.
`cos`	Cosinusul unui unghi dat în radiani.
`hypot`	Ipotenuza: sqrt(x² + y²), fără depășiri pentru numere mari.
`exp`	e la puterea x; inversul lui ln.
`Random.nextInt`	Un Int aleatoriu într-un interval, cu limita de sus exclusă.
`Random.nextDouble`	Un Double aleatoriu, implicit între 0.0 și 1.0 (exclus).
`Random.nextBoolean`	true sau false aleatoriu, cu șanse egale.
`Random`	Generator de numere aleatorii; Random(seed) dă mereu aceeași secvență.
`Random.nextLong`	Un Long aleatoriu într-un interval.
`Duration.inWholeSeconds`	Numărul de secunde întregi dintr-o durată, ca Long.
`Duration.inWholeMilliseconds`	Numărul de milisecunde întregi dintr-o durată, ca Long.
`Int.seconds`	Creează o durată în secunde: 90.seconds (afișat 1m 30s).
`Int.minutes`	Creează o durată în minute: 5.minutes.
`Int.milliseconds`	Creează o durată în milisecunde: 250.milliseconds.
`Int.coerceIn`	Aduce un număr între o limită de jos și una de sus.
`Int.coerceAtLeast`	Returnează numărul, dar cel puțin valoarea minimă dată.
`Int.coerceAtMost`	Returnează numărul, dar cel mult valoarea maximă dată.
`Int.until`	Interval fără capătul de sus: 0 until 5 este 0..4.
`Int.downTo`	Interval descrescător: 5 downTo 1.
`IntProgression.step`	Schimbă pasul unui interval: 0..20 step 5.
`IntRange.contains`	Verifică dacă un număr este în interval: x in 1..10.
`IntRange.first`	Primul număr din interval.
`IntRange.last`	Ultimul număr atins de interval.
`IntRange.reversed`	Același interval parcurs în ordine inversă.
`Int.toString`	Transformă numărul în text, opțional în altă bază (toString(2), toString(16)).
`Int.toDouble`	Transformă un Int în Double, de exemplu pentru împărțire cu zecimale.
`Double.toInt`	Transformă un Double în Int tăind zecimalele (fără rotunjire).
`Int.toChar`	Caracterul cu codul Unicode dat: 65.toChar() este ‘A’.
`Double.roundToInt`	Rotunjește un Double la cel mai apropiat Int (jumătățile în sus).
`Int.rem`	Restul împărțirii (operatorul %), cu semnul deîmpărțitului.
`Int.mod`	Restul împărțirii cu semnul împărțitorului; pentru b pozitiv, între 0 și b – 1.
`Int.countOneBits`	Numărul de biți 1 din reprezentarea binară.
`Double.isNaN`	true dacă valoarea este NaN („nu este număr”).
`Int.MAX_VALUE`	Cea mai mare valoare Int: 2147483647.
`Thread.sleep`	Oprește firul curent pentru un număr de milisecunde.