Kotlin Cheat Sheet: ściąga z Kotlina
Ostatnia aktualizacja
Hello World i podstawy
Program w Kotlinie zaczyna się od funkcji main najwyższego poziomu, bez potrzeby tworzenia klasy.
| Składnia | Znaczenie |
|---|---|
fun main() { println("Hello") } | Punkt wejścia programu |
println("text") | Wypisuje linię na standardowe wyjście |
print("text") | Wypisuje bez znaku nowej linii na końcu |
// comment | Komentarz jednoliniowy |
/* comment */ | Komentarz wieloliniowy |
val input = readLine() | Odczytuje linię ze stdin (typ String? dopuszczający null) |
val line = readln() | Odczytuje linię ze stdin (bez null, Kotlin 1.6+) |
Zmienne (val / var) i typy
Wybieraj val; po var sięgaj tylko wtedy, gdy wartość musi się zmieniać.
| Składnia | Znaczenie |
|---|---|
val name = "Ada" | Zmienna tylko do odczytu, typ wywnioskowany jako String |
var count = 0 | Zmienna modyfikowalna |
val age: Int = 30 | Jawna adnotacja typu |
Int, Long, Double, Float | Typy liczbowe (42, 42L, 3.14, 3.14f) |
Boolean, Char, String | true/false, 'a', "tekst" |
val big = 1_000_000 | Podkreślenia dla czytelnych literałów |
"3".toInt(), "2.5".toDouble() | Zamiana łańcucha na liczbę |
42.toString() | Liczba na łańcuch |
const val MAX = 10 | Stała czasu kompilacji (na najwyższym poziomie lub w object) |
Łańcuchy i szablony
Szablony łańcuchów niemal wszędzie zastępują konkatenację.
| Składnia | Znaczenie |
|---|---|
"Hi, $name" | Wstawia zmienną do łańcucha |
"Total: ${price * qty}" | Wstawia wyrażenie |
s.length | Liczba znaków |
s.uppercase(), s.lowercase() | Zmiana wielkości liter |
s.trim() | Usuwa białe znaki z początku i końca |
s.contains("x"), s.startsWith("a") | Wyszukiwanie w łańcuchu |
s.substring(0, 3) | Wycinek według zakresu indeksów |
s.split(",") | Podział na List<String> |
s[0] | Znak pod indeksem |
"""raw text""" | Surowy łańcuch wieloliniowy, bez escapowania |
"%.2f".format(3.14159) | Sformatowany wynik (3.14) |
Null safety
Typ domyślnie nie dopuszcza null; dodaj ?, aby pozwolić na null, a kompilator zmusi cię do obsłużenia tego przypadku.
| Składnia | Znaczenie |
|---|---|
var s: String? = null | Typ dopuszczający null |
s?.length | Bezpieczne wywołanie: zwraca null, jeśli s to null |
s?.length ?: 0 | Operator Elvis: wartość zastępcza, gdy null |
s!!.length | Asercja not-null: rzuca wyjątek, jeśli s to null |
if (s != null) s.length | Smart cast na typ bez null wewnątrz sprawdzenia |
s?.let { println(it) } | Wykonuje blok tylko wtedy, gdy wartość nie jest null |
val n = s?.toIntOrNull() | Parsowanie albo null przy złych danych |
lateinit var x: String | Zmienna bez null inicjalizowana później |
Operatory
| Operator | Znaczenie |
|---|---|
+ - * / % | Arytmetyka (/ na Int to dzielenie całkowite) |
+= -= *= /= %= | Przypisanie złożone |
++ -- | Inkrementacja / dekrementacja |
== != | Równość strukturalna (wywołuje equals) |
=== !== | Równość referencyjna (ten sam obiekt) |
< > <= >= | Porównanie |
&& || ! | Logiczne i / lub / nie |
a in 1..10 | Przynależność do zakresu lub kolekcji |
x as Int, x as? Int | Rzutowanie / bezpieczne rzutowanie (null przy niepowodzeniu) |
x is String | Sprawdzenie typu (smart cast przy powodzeniu) |
Sterowanie przepływem (if / when)
if i when to wyrażenia: zwracają wartość.
| Składnia | Znaczenie |
|---|---|
if (a > b) x else y | if jako wyrażenie (Kotlin nie ma operatora trójargumentowego ?:) |
if (c) { ... } else if (d) { ... } else { ... } | Łańcuch gałęzi |
when (x) { 1 -> "one"; 2 -> "two"; else -> "other" } | Dopasowanie wartości |
when (x) { 1, 2 -> "low" } | Kilka wartości w jednej gałęzi |
when (x) { in 1..9 -> "digit" } | Dopasowanie zakresu |
when (x) { is String -> x.length } | Dopasowanie typu (ze smart castem) |
when { x < 0 -> "neg"; x == 0 -> "zero"; else -> "pos" } | when bez argumentu, jak if/else if |
val label = when (x) { ... } | when jako wyrażenie (wymaga else) |
Pętle i zakresy
| Składnia | Znaczenie |
|---|---|
for (i in 1..5) | Zakres domknięty od 1 do 5 |
for (i in 1 until 5) | Od 1 do 4 (bez wartości końcowej) |
for (i in 0..<5) | To samo, składnia zakresu otwartego (Kotlin 1.9+) |
for (i in 10 downTo 1 step 2) | Odliczanie w dół z krokiem |
for (item in list) | Iteracja po kolekcji |
for ((i, item) in list.withIndex()) | Indeks i element razem |
for (ch in "abc") | Iteracja po znakach łańcucha |
while (cond) { ... } | Pętla, dopóki warunek jest prawdziwy |
do { ... } while (cond) | Wykonuje się co najmniej raz |
break, continue | Wyjście z pętli / przejście do następnej iteracji |
repeat(3) { println(it) } | Wykonuje blok n razy |
Funkcje
| Składnia | Znaczenie |
|---|---|
fun add(a: Int, b: Int): Int { return a + b } | Deklaracja funkcji |
fun add(a: Int, b: Int) = a + b | Funkcja z jednym wyrażeniem, typ zwracany wywnioskowany |
fun greet(name: String = "world") | Domyślna wartość parametru |
greet(name = "Ada") | Argument nazwany |
fun log(vararg items: String) | Zmienna liczba argumentów |
fun say(): Unit | Bez wartości zwracanej (Unit jest opcjonalny) |
val square = { x: Int -> x * x } | Lambda zapisana w zmiennej |
fun String.shout() = uppercase() + "!" | Funkcja rozszerzająca |
fun apply(f: (Int) -> Int) = f(2) | Funkcja jako parametr |
list.map { it * 2 } | Lambda na końcu wywołania, it to jedyny parametr |
Listy
listOf jest tylko do odczytu; mutableListOf można zmieniać.
| Składnia | Znaczenie |
|---|---|
val nums = listOf(1, 2, 3) | Lista tylko do odczytu |
val items = mutableListOf("a") | Lista modyfikowalna |
nums[0], nums.first(), nums.last() | Dostęp do elementów |
nums.getOrNull(9) | Bezpieczny dostęp, null poza zakresem |
items.add("b"), items.remove("a") | Dodanie / usunięcie |
items[0] = "z" | Zamiana po indeksie |
nums.size, nums.isEmpty() | Rozmiar i sprawdzenie pustości |
x in nums, nums.contains(x) | Przynależność |
nums.indexOf(2) | Pozycja elementu, -1, jeśli go nie ma |
nums.subList(0, 2) | Wycinek (bez elementu końcowego) |
nums.take(2), nums.drop(1) | Pierwsze n / wszystkie oprócz pierwszych n |
nums.sorted(), nums.reversed() | Nowa lista posortowana / odwrócona |
nums.sum(), nums.average(), nums.maxOrNull() | Agregaty |
nums.joinToString(", ") | Łączy w jeden łańcuch |
Pair(1, "a"), 1 to "a", Triple(1, 2, 3) | Małe krotki o stałym rozmiarze |
Mapy i zbiory
| Składnia | Znaczenie |
|---|---|
val m = mapOf("a" to 1, "b" to 2) | Mapa tylko do odczytu |
val mm = mutableMapOf<String, Int>() | Mapa modyfikowalna |
m["a"] | Odczyt (null, jeśli brak) |
m.getOrDefault("z", 0) | Odczyt z wartością zastępczą |
mm["c"] = 3 | Wstawienie lub aktualizacja |
for ((k, v) in m) | Iteracja po wpisach z destrukturyzacją |
m.keys, m.values | Kolekcje kluczy / wartości |
"a" in m | Sprawdzenie klucza |
val s = setOf(1, 2, 2) | Zbiór unikalnych wartości ({1, 2}) |
mutableSetOf<Int>() | Zbiór modyfikowalny |
Operacje na kolekcjach (lambdy)
| Składnia | Znaczenie |
|---|---|
list.map { it * 2 } | Przekształca każdy element |
list.filter { it > 2 } | Zachowuje pasujące elementy |
list.forEach { println(it) } | Wykonuje coś dla każdego elementu |
list.any { it > 2 }, list.all { it > 0 } | Czy pasuje którykolwiek / każdy element |
list.count { it % 2 == 0 } | Zlicza dopasowania |
list.find { it > 2 } | Pierwsze dopasowanie albo null |
list.sortedBy { it.length } | Sortuje według klucza |
list.groupBy { it.first() } | Grupuje w Map |
list.distinct() | Usuwa duplikaty |
list.fold(0) { acc, x -> acc + x } | Redukcja z wartością początkową |
list.zip(other) | Łączy dwie listy w pary |
list.flatMap { it.toList() } | Mapuje, a potem spłaszcza |
Klasy i data classes
| Składnia | Znaczenie |
|---|---|
class User(val name: String, var age: Int) | Klasa z konstruktorem głównym i właściwościami |
val u = User("Ada", 36) | Tworzenie instancji (bez new) |
u.name, u.age = 37 | Odczyt / zapis właściwości |
data class Point(val x: Int, val y: Int) | equals, hashCode, toString, copy w pakiecie |
p.copy(y = 5) | Kopia ze zmienionymi niektórymi właściwościami |
val (x, y) = p | Deklaracja destrukturyzująca |
open class Base, class Sub : Base() | Dziedziczenie (klasy są domyślnie final) |
override fun toString() = "..." | Nadpisanie składowej |
object Config { val debug = true } | Singleton |
companion object { fun create() = User("", 0) } | Składowe podobne do statycznych |
enum class Color { RED, GREEN } | Typ wyliczeniowy |
sealed class Result | Zamknięta hierarchia klas, wyczerpująca w when |
interface Shape { fun area(): Double } | Interfejs |
Obsługa błędów
| Składnia | Znaczenie |
|---|---|
try { ... } catch (e: Exception) { ... } | Przechwycenie wyjątku |
try { ... } finally { ... } | Sprzątanie wykonywane zawsze |
val n = try { s.toInt() } catch (e: NumberFormatException) { 0 } | try jako wyrażenie |
throw IllegalArgumentException("bad") | Rzucenie wyjątku |
require(x > 0) { "x must be positive" } | Sprawdzenie argumentu (rzuca IllegalArgumentException) |
check(ready) { "not ready" } | Sprawdzenie stanu (rzuca IllegalStateException) |
s.toIntOrNull() | Zwraca null zamiast rzucać wyjątek |
runCatching { risky() }.getOrDefault(0) | Opakowuje wywołanie w Result |
Funkcje zakresu
Pięć małych funkcji pomocniczych do pracy z obiektem wewnątrz bloku.
| Składnia | Znaczenie |
|---|---|
x.let { it + 1 } | it to obiekt, zwraca wynik bloku |
x.run { this + 1 } | this to obiekt, zwraca wynik bloku |
x.apply { field = 1 } | this to obiekt, zwraca obiekt |
x.also { println(it) } | it to obiekt, zwraca obiekt |
with(x) { field } | Nie jest rozszerzeniem; this to x, zwraca wynik bloku |
x?.let { ... } | Idiomatyczne sprawdzenie null i użycie |
Cała składnia Kotlina, po którą sięgasz, na jednej stronie. Ten Kotlin cheat sheet to szybka ściąga z języka, na którym stoi Android i duża część nowoczesnej JVM: deklarowanie zmiennych, bezpieczna obsługa null, rozgałęzienia z when, pętle po zakresach, pisanie funkcji oraz praca z listami i mapami.
Wszystko tutaj to standardowy Kotlin, który działa tak samo na JVM, Androidzie i w Kotlin Multiplatform. Skopiuj to, czego potrzebujesz, albo wypróbuj w edytorze online Kotlin: wklej fragment, naciśnij Run i zobacz wynik w przeglądarce.
Kotlin cheat sheet: najczęstsze pytania
Czy ten Kotlin cheat sheet jest darmowy?
Tak. Ta ściąga z Kotlina jest całkowicie darmowa i nie wymaga rejestracji. Dodaj ją do zakładek i wracaj, gdy potrzebujesz sprawdzić gałąź
when, operator null safety albo metodę kolekcji.Czym różni się val od var w Kotlinie?
val deklaruje referencję tylko do odczytu: przypisuje się ją raz i nie można jej przypisać ponownie. var deklaruje zmienną modyfikowalną, którą można przypisać ponownie. Pamiętaj, że val ustala tylko referencję: do val list = mutableListOf(1) nadal można dodawać elementy. Styl Kotlina to używanie val wszędzie i przechodzenie na var tylko wtedy, gdy ponowne przypisanie jest naprawdę potrzebne.Jak działa null safety w Kotlinie?
Typy domyślnie nie dopuszczają null, więc
String nigdy nie może zawierać null, a String? może. Kompilator nie pozwoli wywołać metody na wartości dopuszczającej null bez obsłużenia przypadku null: przez bezpieczne wywołanie (s?.length), wartość zastępczą z operatorem Elvis (s?.length ?: 0), sprawdzenie null ze smart castem (if (s != null)) albo, w ostateczności, asercję not-null s!!, która rzuca NullPointerException, jeśli wartość faktycznie jest null.Kiedy w Kotlinie używać when zamiast if?
Używaj
when zawsze, gdy porównujesz jedną wartość z kilkoma możliwościami (stałymi, zakresami, typami albo ich mieszanką), a if/else dla pojedynczego warunku tak lub nie. Oba są wyrażeniami, więc zarówno val label = when (x) { ... }, jak i val label = if (c) a else b są idiomatyczne. when użyte jako wyrażenie musi być wyczerpujące, co zwykle oznacza dodanie gałęzi else (klasy zapieczętowane i typy wyliczeniowe mogą być wyczerpujące bez niej).Czy mogę ćwiczyć Kotlina online?
Tak. Otwórz edytor online Kotlin, aby uruchomić dowolny fragment z tej ściągi w przeglądarce, bez instalowania JDK ani IntelliJ. Gdy chcesz uczyć się bardziej systematycznie, darmowy interaktywny kurs Kotlina w Coddy prowadzi od Hello World przez null safety,
when, pętle, funkcje i kolekcje, a na końcu wydaje darmowy certyfikat.Powiązane materiały
Więcej ściąg
