Kotlin Cheat Sheet
Zuletzt aktualisiert
Hello World & Grundlagen
Ein Kotlin-Programm beginnt bei einer Top-Level-Funktion main - keine Klasse nötig.
| Syntax | Bedeutung |
|---|---|
fun main() { println("Hello") } | Einstiegspunkt eines Programms |
println("text") | Eine Zeile auf die Standardausgabe schreiben |
print("text") | Ausgeben ohne Zeilenumbruch am Ende |
// comment | Einzeiliger Kommentar |
/* comment */ | Mehrzeiliger Kommentar |
val input = readLine() | Eine Zeile von stdin lesen (nullbares String?) |
val line = readln() | Eine Zeile von stdin lesen (nicht-null, Kotlin 1.6+) |
Variablen (val / var) & Typen
Bevorzuge val; nimm var nur, wenn sich der Wert ändern muss.
| Syntax | Bedeutung |
|---|---|
val name = "Ada" | Schreibgeschützte Variable, Typ als String abgeleitet |
var count = 0 | Veränderbare Variable |
val age: Int = 30 | Explizite Typangabe |
Int, Long, Double, Float | Numerische Typen (42, 42L, 3.14, 3.14f) |
Boolean, Char, String | true/false, 'a', "text" |
val big = 1_000_000 | Unterstriche für lesbare Literale |
"3".toInt(), "2.5".toDouble() | Einen String in eine Zahl umwandeln |
42.toString() | Zahl in String |
const val MAX = 10 | Compile-Zeit-Konstante (Top-Level oder in einem object) |
Strings & Templates
String-Templates ersetzen fast überall die Verkettung.
| Syntax | Bedeutung |
|---|---|
"Hi, $name" | Eine Variable in einen String einfügen |
"Total: ${price * qty}" | Einen Ausdruck einfügen |
s.length | Anzahl der Zeichen |
s.uppercase(), s.lowercase() | Groß-/Kleinschreibung ändern |
s.trim() | Leerraum am Anfang und Ende entfernen |
s.contains("x"), s.startsWith("a") | In einem String suchen |
s.substring(0, 3) | Teilstring nach Indexbereich |
s.split(",") | In eine List<String> aufteilen |
s[0] | Zeichen an einem Index |
"""raw text""" | Roher mehrzeiliger String, kein Escaping |
"%.2f".format(3.14159) | Formatierte Ausgabe (3.14) |
Null-Safety
Ein Typ ist standardmäßig nicht-null; mit ? erlaubst du null, und der Compiler zwingt dich, den Fall zu behandeln.
| Syntax | Bedeutung |
|---|---|
var s: String? = null | Nullbarer Typ |
s?.length | Safe Call - liefert null, wenn s null ist |
s?.length ?: 0 | Elvis-Operator - Ersatzwert bei null |
s!!.length | Not-Null-Assertion - wirft, wenn s null ist |
if (s != null) s.length | Smart Cast auf nicht-null innerhalb der Prüfung |
s?.let { println(it) } | Einen Block nur ausführen, wenn nicht null |
val n = s?.toIntOrNull() | Parsen, bei ungültiger Eingabe null |
lateinit var x: String | Nicht-null-Variable, die später initialisiert wird |
Operatoren
| Operator | Bedeutung |
|---|---|
+ - * / % | Arithmetik (/ auf Ints ist Ganzzahldivision) |
+= -= *= /= %= | Zusammengesetzte Zuweisung |
++ -- | Inkrement / Dekrement |
== != | Strukturelle Gleichheit (ruft equals auf) |
=== !== | Referenzgleichheit (dasselbe Objekt) |
< > <= >= | Vergleich |
&& || ! | Logisches Und / Oder / Nicht |
a in 1..10 | Enthalten in Range oder Collection |
x as Int, x as? Int | Cast / sicherer Cast (null bei Fehlschlag) |
x is String | Typprüfung (Smart Cast bei Erfolg) |
Kontrollfluss (if / when)
if und when sind Ausdrücke - sie liefern einen Wert.
| Syntax | Bedeutung |
|---|---|
if (a > b) x else y | if als Ausdruck (Kotlin hat keinen ternären ?:-Operator) |
if (c) { ... } else if (d) { ... } else { ... } | Verkettete Zweige |
when (x) { 1 -> "one"; 2 -> "two"; else -> "other" } | Einen Wert abgleichen |
when (x) { 1, 2 -> "low" } | Mehrere Werte in einem Zweig |
when (x) { in 1..9 -> "digit" } | Einen Bereich abgleichen |
when (x) { is String -> x.length } | Einen Typ abgleichen (mit Smart Cast) |
when { x < 0 -> "neg"; x == 0 -> "zero"; else -> "pos" } | when ohne Subjekt, wie if/else if |
val label = when (x) { ... } | when als Ausdruck (braucht else) |
Schleifen & Ranges
| Syntax | Bedeutung |
|---|---|
for (i in 1..5) | Inklusiver Bereich 1 bis 5 |
for (i in 1 until 5) | 1 bis 4 (Ende exklusiv) |
for (i in 0..<5) | Dasselbe mit offener Range-Syntax (Kotlin 1.9+) |
for (i in 10 downTo 1 step 2) | In Schritten herunterzählen |
for (item in list) | Über eine Collection iterieren |
for ((i, item) in list.withIndex()) | Index und Element zusammen |
for (ch in "abc") | Über die Zeichen eines Strings iterieren |
while (cond) { ... } | Schleife, solange wahr |
do { ... } while (cond) | Mindestens einmal ausführen |
break, continue | Schleife verlassen / zur nächsten Iteration springen |
repeat(3) { println(it) } | Einen Block n-mal ausführen |
Funktionen
| Syntax | Bedeutung |
|---|---|
fun add(a: Int, b: Int): Int { return a + b } | Eine Funktion deklarieren |
fun add(a: Int, b: Int) = a + b | Funktion mit einem Ausdruck, Rückgabetyp abgeleitet |
fun greet(name: String = "world") | Standardwert für einen Parameter |
greet(name = "Ada") | Benanntes Argument |
fun log(vararg items: String) | Variable Anzahl an Argumenten |
fun say(): Unit | Kein Rückgabewert (Unit ist optional) |
val square = { x: Int -> x * x } | Lambda in einer Variablen gespeichert |
fun String.shout() = uppercase() + "!" | Extension-Funktion |
fun apply(f: (Int) -> Int) = f(2) | Funktion als Parameter |
list.map { it * 2 } | Trailing Lambda, it ist der einzige Parameter |
Listen
listOf ist schreibgeschützt; mutableListOf lässt sich ändern.
| Syntax | Bedeutung |
|---|---|
val nums = listOf(1, 2, 3) | Schreibgeschützte Liste |
val items = mutableListOf("a") | Veränderbare Liste |
nums[0], nums.first(), nums.last() | Auf Elemente zugreifen |
nums.getOrNull(9) | Sicherer Zugriff, null außerhalb des Bereichs |
items.add("b"), items.remove("a") | Hinzufügen / entfernen |
items[0] = "z" | Nach Index ersetzen |
nums.size, nums.isEmpty() | Größe und Leerheit |
x in nums, nums.contains(x) | Enthalten-Prüfung |
nums.indexOf(2) | Position eines Elements, -1 wenn nicht vorhanden |
nums.subList(0, 2) | Teilliste (Ende exklusiv) |
nums.take(2), nums.drop(1) | Die ersten n / alle außer den ersten n |
nums.sorted(), nums.reversed() | Neue sortierte / umgekehrte Liste |
nums.sum(), nums.average(), nums.maxOrNull() | Aggregate |
nums.joinToString(", ") | Zu einem String verbinden |
Pair(1, "a"), 1 to "a", Triple(1, 2, 3) | Kleine feste Tupel |
Maps & Sets
| Syntax | Bedeutung |
|---|---|
val m = mapOf("a" to 1, "b" to 2) | Schreibgeschützte Map |
val mm = mutableMapOf<String, Int>() | Veränderbare Map |
m["a"] | Nachschlagen (null wenn nicht vorhanden) |
m.getOrDefault("z", 0) | Nachschlagen mit Ersatzwert |
mm["c"] = 3 | Einfügen oder aktualisieren |
for ((k, v) in m) | Über Einträge mit Destructuring iterieren |
m.keys, m.values | Collections der Schlüssel / Werte |
"a" in m | Schlüssel enthalten? |
val s = setOf(1, 2, 2) | Set eindeutiger Werte ({1, 2}) |
mutableSetOf<Int>() | Veränderbares Set |
Collection-Operationen (Lambdas)
| Syntax | Bedeutung |
|---|---|
list.map { it * 2 } | Jedes Element transformieren |
list.filter { it > 2 } | Passende Elemente behalten |
list.forEach { println(it) } | Etwas mit jedem Element tun |
list.any { it > 2 }, list.all { it > 0 } | Passt irgendein / jedes Element |
list.count { it % 2 == 0 } | Treffer zählen |
list.find { it > 2 } | Erster Treffer oder null |
list.sortedBy { it.length } | Nach einem Schlüssel sortieren |
list.groupBy { it.first() } | In eine Map gruppieren |
list.distinct() | Duplikate entfernen |
list.fold(0) { acc, x -> acc + x } | Mit Startwert reduzieren |
list.zip(other) | Zwei Listen paaren |
list.flatMap { it.toList() } | Abbilden und dann flachziehen |
Klassen & Data Classes
| Syntax | Bedeutung |
|---|---|
class User(val name: String, var age: Int) | Klasse mit Primärkonstruktor und Properties |
val u = User("Ada", 36) | Eine Instanz erzeugen (kein new) |
u.name, u.age = 37 | Properties lesen / schreiben |
data class Point(val x: Int, val y: Int) | equals, hashCode, toString, copy gratis |
p.copy(y = 5) | Kopie mit geänderten Properties |
val (x, y) = p | Destructuring-Deklaration |
open class Base, class Sub : Base() | Vererbung (Klassen sind standardmäßig final) |
override fun toString() = "..." | Ein Member überschreiben |
object Config { val debug = true } | Singleton |
companion object { fun create() = User("", 0) } | Statisch-ähnliche Member |
enum class Color { RED, GREEN } | Enum |
sealed class Result | Eingeschränkte Klassenhierarchie, vollständig in when |
interface Shape { fun area(): Double } | Interface |
Fehlerbehandlung
| Syntax | Bedeutung |
|---|---|
try { ... } catch (e: Exception) { ... } | Eine Exception fangen |
try { ... } finally { ... } | Aufräumen immer ausführen |
val n = try { s.toInt() } catch (e: NumberFormatException) { 0 } | try als Ausdruck |
throw IllegalArgumentException("bad") | Eine Exception werfen |
require(x > 0) { "x must be positive" } | Argumentprüfung (wirft IllegalArgumentException) |
check(ready) { "not ready" } | Zustandsprüfung (wirft IllegalStateException) |
s.toIntOrNull() | null zurückgeben statt zu werfen |
runCatching { risky() }.getOrDefault(0) | Einen Aufruf in ein Result verpacken |
Scope-Funktionen
Fünf kleine Helfer, um mit einem Objekt in einem Block zu arbeiten.
| Syntax | Bedeutung |
|---|---|
x.let { it + 1 } | it ist das Objekt, liefert das Blockergebnis |
x.run { this + 1 } | this ist das Objekt, liefert das Blockergebnis |
x.apply { field = 1 } | this ist das Objekt, liefert das Objekt |
x.also { println(it) } | it ist das Objekt, liefert das Objekt |
with(x) { field } | Keine Extension; this ist x, liefert das Blockergebnis |
x?.let { ... } | Die idiomatische Null-Prüfung + Verwendung |
Jedes Stück Kotlin-Syntax, das du brauchst, auf einer Seite. Dieses Kotlin Cheat Sheet ist eine Schnellreferenz für die Sprache hinter Android und einem großen Teil der modernen JVM - Variablen deklarieren, sicher mit null umgehen, mit when verzweigen, über Ranges iterieren, Funktionen schreiben und mit Listen und Maps arbeiten.
Alles hier ist Standard-Kotlin und läuft gleichermaßen auf der JVM, unter Android und mit Kotlin Multiplatform. Kopiere, was du brauchst, oder probiere es live im Kotlin-Playground aus - Snippet einfügen, Run drücken und die Ausgabe im Browser sehen.
Kotlin Cheat Sheet FAQ
Ist dieses Kotlin Cheat Sheet kostenlos?
Ja. Dieses Kotlin Cheat Sheet ist komplett kostenlos, ohne Anmeldung. Setz ein Lesezeichen und komm zurück, wann immer du einen
when-Zweig, einen Null-Safety-Operator oder eine Collection-Methode nachschlagen willst.Was ist der Unterschied zwischen val und var in Kotlin?
val deklariert eine schreibgeschützte Referenz: Sie wird einmal zugewiesen und kann nicht neu zugewiesen werden. var deklariert eine veränderbare Variable, die neu zugewiesen werden kann. Beachte, dass val nur die Referenz festlegt - einer val list = mutableListOf(1) können trotzdem Elemente hinzugefügt werden. Kotlin-Stil ist, überall val zu verwenden und nur dann auf var zu wechseln, wenn eine Neuzuweisung wirklich nötig ist.Wie funktioniert Null-Safety in Kotlin?
Typen sind standardmäßig nicht-null,
String kann also nie null enthalten; String? schon. Der Compiler lässt dich keine Methode auf einem nullbaren Wert aufrufen, ohne den null-Fall zu behandeln - mit einem Safe Call (s?.length), einem Elvis-Fallback (s?.length ?: 0), einer Null-Prüfung mit Smart Cast (if (s != null)) oder, als letztes Mittel, der Not-Null-Assertion s!!, die eine NullPointerException wirft, wenn der Wert tatsächlich null ist.Wann sollte ich in Kotlin when statt if verwenden?
Verwende
when, wenn du einen Wert mit mehreren Möglichkeiten vergleichst - Konstanten, Ranges, Typen oder eine Mischung - und if/else für eine einzelne Ja-oder-Nein-Bedingung. Beide sind Ausdrücke, also sind val label = when (x) { ... } und val label = if (c) a else b beide idiomatisch. Ein when als Ausdruck muss vollständig sein, was meist einen else-Zweig bedeutet (Sealed Classes und Enums kommen auch ohne aus).Kann ich Kotlin online üben?
Ja. Öffne den Kotlin-Playground und führe jedes Snippet aus diesem Cheat Sheet im Browser aus - ohne JDK oder IntelliJ zu installieren. Wenn du Struktur willst, führt dich Coddys kostenloser interaktiver Kotlin-Kurs von Hello World über Null-Safety,
when, Schleifen, Funktionen und Collections und stellt am Ende ein kostenloses Zertifikat aus.Verwandte Ressourcen
Weitere Spickzettel
