Kotlin Cheat Sheet
Dernière mise à jour
Hello World et bases
Un programme Kotlin commence par une fonction main de premier niveau : aucune classe requise.
| Syntaxe | Signification |
|---|---|
fun main() { println("Hello") } | Point d'entrée d'un programme |
println("text") | Afficher une ligne sur la sortie standard |
print("text") | Afficher sans retour à la ligne final |
// comment | Commentaire sur une ligne |
/* comment */ | Commentaire multiligne |
val input = readLine() | Lire une ligne depuis stdin (String? nullable) |
val line = readln() | Lire une ligne depuis stdin (non null, Kotlin 1.6+) |
Variables (val / var) et types
Préfère val ; n'utilise var que si la valeur doit changer.
| Syntaxe | Signification |
|---|---|
val name = "Ada" | Variable en lecture seule, type inféré String |
var count = 0 | Variable mutable |
val age: Int = 30 | Annotation de type explicite |
Int, Long, Double, Float | Types numériques (42, 42L, 3.14, 3.14f) |
Boolean, Char, String | true/false, 'a', "texte" |
val big = 1_000_000 | Underscores pour des littéraux lisibles |
"3".toInt(), "2.5".toDouble() | Convertir une chaîne en nombre |
42.toString() | Nombre vers chaîne |
const val MAX = 10 | Constante de compilation (premier niveau ou dans un object) |
Chaînes et templates
Les templates de chaînes remplacent la concaténation presque partout.
| Syntaxe | Signification |
|---|---|
"Hi, $name" | Insérer une variable dans une chaîne |
"Total: ${price * qty}" | Insérer une expression |
s.length | Nombre de caractères |
s.uppercase(), s.lowercase() | Changer la casse |
s.trim() | Supprimer les espaces en début et fin |
s.contains("x"), s.startsWith("a") | Chercher dans une chaîne |
s.substring(0, 3) | Extraire par plage d'indices |
s.split(",") | Découper en List<String> |
s[0] | Caractère à un indice |
"""raw text""" | Chaîne brute multiligne, sans échappement |
"%.2f".format(3.14159) | Sortie formatée (3.14) |
Null safety
Un type est non nullable par défaut ; ajoute ? pour autoriser null, et le compilateur t'oblige à le gérer.
| Syntaxe | Signification |
|---|---|
var s: String? = null | Type nullable |
s?.length | Appel sûr : renvoie null si s est null |
s?.length ?: 0 | Opérateur Elvis : valeur de repli si null |
s!!.length | Assertion non-null : lève une exception si s est null |
if (s != null) s.length | Smart cast vers non-null à l'intérieur du test |
s?.let { println(it) } | Exécuter un bloc seulement si non null |
val n = s?.toIntOrNull() | Convertir, ou null si l'entrée est invalide |
lateinit var x: String | Variable non nullable initialisée plus tard |
Opérateurs
| Opérateur | Signification |
|---|---|
+ - * / % | Arithmétique (/ entre Int est une division entière) |
+= -= *= /= %= | Affectation composée |
++ -- | Incrément / décrément |
== != | Égalité structurelle (appelle equals) |
=== !== | Égalité référentielle (même objet) |
< > <= >= | Comparaison |
&& || ! | Et / ou / non logiques |
a in 1..10 | Appartenance à une range ou une collection |
x as Int, x as? Int | Cast / cast sûr (null en cas d'échec) |
x is String | Test de type (smart cast en cas de succès) |
Flux de contrôle (if / when)
if et when sont des expressions : ils renvoient une valeur.
| Syntaxe | Signification |
|---|---|
if (a > b) x else y | if comme expression (Kotlin n'a pas d'opérateur ternaire ?:) |
if (c) { ... } else if (d) { ... } else { ... } | Branches enchaînées |
when (x) { 1 -> "one"; 2 -> "two"; else -> "other" } | Comparer à une valeur |
when (x) { 1, 2 -> "low" } | Plusieurs valeurs dans une branche |
when (x) { in 1..9 -> "digit" } | Comparer à une range |
when (x) { is String -> x.length } | Comparer à un type (avec smart cast) |
when { x < 0 -> "neg"; x == 0 -> "zero"; else -> "pos" } | when sans sujet, comme if/else if |
val label = when (x) { ... } | when comme expression (nécessite else) |
Boucles et ranges
| Syntaxe | Signification |
|---|---|
for (i in 1..5) | Range inclusive de 1 à 5 |
for (i in 1 until 5) | De 1 à 4 (fin exclue) |
for (i in 0..<5) | Idem avec la syntaxe de range ouverte (Kotlin 1.9+) |
for (i in 10 downTo 1 step 2) | Compter à rebours par pas |
for (item in list) | Parcourir une collection |
for ((i, item) in list.withIndex()) | Indice et élément ensemble |
for (ch in "abc") | Parcourir les caractères d'une chaîne |
while (cond) { ... } | Boucler tant que vrai |
do { ... } while (cond) | Exécuter au moins une fois |
break, continue | Sortir de la boucle / passer à l'itération suivante |
repeat(3) { println(it) } | Exécuter un bloc n fois |
Fonctions
| Syntaxe | Signification |
|---|---|
fun add(a: Int, b: Int): Int { return a + b } | Déclarer une fonction |
fun add(a: Int, b: Int) = a + b | Fonction à expression unique, type de retour inféré |
fun greet(name: String = "world") | Valeur par défaut d'un paramètre |
greet(name = "Ada") | Argument nommé |
fun log(vararg items: String) | Nombre variable d'arguments |
fun say(): Unit | Pas de valeur de retour (Unit est facultatif) |
val square = { x: Int -> x * x } | Lambda stockée dans une variable |
fun String.shout() = uppercase() + "!" | Fonction d'extension |
fun apply(f: (Int) -> Int) = f(2) | Fonction en paramètre |
list.map { it * 2 } | Trailing lambda, it est l'unique paramètre |
Listes
listOf est en lecture seule ; mutableListOf peut être modifiée.
| Syntaxe | Signification |
|---|---|
val nums = listOf(1, 2, 3) | Liste en lecture seule |
val items = mutableListOf("a") | Liste mutable |
nums[0], nums.first(), nums.last() | Accéder aux éléments |
nums.getOrNull(9) | Accès sûr, null si hors limites |
items.add("b"), items.remove("a") | Ajouter / supprimer |
items[0] = "z" | Remplacer par indice |
nums.size, nums.isEmpty() | Taille et vacuité |
x in nums, nums.contains(x) | Appartenance |
nums.indexOf(2) | Position d'un élément, -1 s'il est absent |
nums.subList(0, 2) | Sous-liste (fin exclue) |
nums.take(2), nums.drop(1) | Les n premiers / tous sauf les n premiers |
nums.sorted(), nums.reversed() | Nouvelle liste triée / inversée |
nums.sum(), nums.average(), nums.maxOrNull() | Agrégats |
nums.joinToString(", ") | Joindre en une seule chaîne |
Pair(1, "a"), 1 to "a", Triple(1, 2, 3) | Petits tuples de taille fixe |
Maps et sets
| Syntaxe | Signification |
|---|---|
val m = mapOf("a" to 1, "b" to 2) | Map en lecture seule |
val mm = mutableMapOf<String, Int>() | Map mutable |
m["a"] | Recherche (null si absent) |
m.getOrDefault("z", 0) | Recherche avec valeur de repli |
mm["c"] = 3 | Insérer ou mettre à jour |
for ((k, v) in m) | Parcourir les entrées avec déstructuration |
m.keys, m.values | Collections des clés / valeurs |
"a" in m | Présence d'une clé |
val s = setOf(1, 2, 2) | Set de valeurs uniques ({1, 2}) |
mutableSetOf<Int>() | Set mutable |
Opérations sur les collections (lambdas)
| Syntaxe | Signification |
|---|---|
list.map { it * 2 } | Transformer chaque élément |
list.filter { it > 2 } | Garder les éléments correspondants |
list.forEach { println(it) } | Faire quelque chose avec chacun |
list.any { it > 2 }, list.all { it > 0 } | Un élément / chaque élément correspond-il |
list.count { it % 2 == 0 } | Compter les correspondances |
list.find { it > 2 } | Première correspondance ou null |
list.sortedBy { it.length } | Trier par une clé |
list.groupBy { it.first() } | Grouper dans une Map |
list.distinct() | Supprimer les doublons |
list.fold(0) { acc, x -> acc + x } | Réduire avec une valeur initiale |
list.zip(other) | Apparier deux listes |
list.flatMap { it.toList() } | Transformer puis aplatir |
Classes et data classes
| Syntaxe | Signification |
|---|---|
class User(val name: String, var age: Int) | Classe avec constructeur primaire et propriétés |
val u = User("Ada", 36) | Créer une instance (sans new) |
u.name, u.age = 37 | Lire / écrire des propriétés |
data class Point(val x: Int, val y: Int) | equals, hashCode, toString, copy gratuitement |
p.copy(y = 5) | Copie avec certaines propriétés modifiées |
val (x, y) = p | Déclaration par déstructuration |
open class Base, class Sub : Base() | Héritage (les classes sont final par défaut) |
override fun toString() = "..." | Redéfinir un membre |
object Config { val debug = true } | Singleton |
companion object { fun create() = User("", 0) } | Membres de type statique |
enum class Color { RED, GREEN } | Enum |
sealed class Result | Hiérarchie de classes restreinte, exhaustive dans when |
interface Shape { fun area(): Double } | Interface |
Gestion des erreurs
| Syntaxe | Signification |
|---|---|
try { ... } catch (e: Exception) { ... } | Attraper une exception |
try { ... } finally { ... } | Toujours exécuter le nettoyage |
val n = try { s.toInt() } catch (e: NumberFormatException) { 0 } | try comme expression |
throw IllegalArgumentException("bad") | Lever une exception |
require(x > 0) { "x must be positive" } | Vérification d'argument (lève IllegalArgumentException) |
check(ready) { "not ready" } | Vérification d'état (lève IllegalStateException) |
s.toIntOrNull() | Renvoyer null au lieu de lever une exception |
runCatching { risky() }.getOrDefault(0) | Envelopper un appel dans un Result |
Fonctions de portée
Cinq petits utilitaires pour travailler avec un objet dans un bloc.
| Syntaxe | Signification |
|---|---|
x.let { it + 1 } | it est l'objet, renvoie le résultat du bloc |
x.run { this + 1 } | this est l'objet, renvoie le résultat du bloc |
x.apply { field = 1 } | this est l'objet, renvoie l'objet |
x.also { println(it) } | it est l'objet, renvoie l'objet |
with(x) { field } | Pas une extension ; this est x, renvoie le résultat du bloc |
x?.let { ... } | Le test de nullité idiomatique + utilisation |
Toute la syntaxe Kotlin dont tu as besoin, sur une seule page. Cette cheat sheet Kotlin est une référence rapide du langage derrière Android et une bonne partie de la JVM moderne : déclarer des variables, gérer les nulls en sécurité, brancher avec when, parcourir des ranges, écrire des fonctions et manipuler listes et maps.
Tout ici est du Kotlin standard qui tourne aussi bien sur la JVM, sur Android et avec Kotlin Multiplatform. Copie ce dont tu as besoin, ou essaie-le en direct dans le playground Kotlin : colle un extrait, appuie sur Run et vois la sortie dans ton navigateur.
FAQ de la cheat sheet Kotlin
Cette cheat sheet Kotlin est-elle gratuite ?
Oui. Cette cheat sheet Kotlin est entièrement gratuite, sans inscription. Mets-la en favori et reviens dès que tu dois vérifier une branche
when, un opérateur de null safety ou une méthode de collection.Quelle est la différence entre val et var en Kotlin ?
val déclare une référence en lecture seule : elle est assignée une fois et ne peut pas être réassignée. var déclare une variable mutable qui peut être réassignée. Note que val ne fige que la référence : on peut toujours ajouter des éléments à une val list = mutableListOf(1). Le style Kotlin consiste à utiliser val partout et à passer à var seulement quand la réassignation est vraiment nécessaire.Comment fonctionne la null safety en Kotlin ?
Les types sont non nullables par défaut, donc
String ne peut jamais contenir null ; String? le peut. Le compilateur refuse d'appeler une méthode sur une valeur nullable sans que le cas null soit géré : par un appel sûr (s?.length), une valeur de repli avec Elvis (s?.length ?: 0), un test de nullité avec smart cast (if (s != null)) ou, en dernier recours, l'assertion non-null s!!, qui lève une NullPointerException si la valeur est réellement null.Quand utiliser when plutôt que if en Kotlin ?
Utilise
when dès que tu compares une valeur à plusieurs possibilités (constantes, ranges, types ou un mélange) et if/else pour une seule condition oui/non. Les deux sont des expressions, donc val label = when (x) { ... } et val label = if (c) a else b sont idiomatiques. Un when utilisé comme expression doit être exhaustif, ce qui signifie généralement ajouter une branche else (les sealed classes et les enums peuvent être exhaustifs sans elle).Puis-je pratiquer Kotlin en ligne ?
Oui. Ouvre le playground Kotlin pour exécuter n'importe quel extrait de cette cheat sheet dans ton navigateur, sans installer le JDK ni IntelliJ. Quand tu veux de la structure, le cours Kotlin interactif et gratuit de Coddy te mène de Hello World à la null safety,
when, les boucles, les fonctions et les collections, avec un certificat gratuit à la fin.Ressources connexes
Plus d'aide-mémoires
