Kotlin Cheat Sheet
Última atualização
Hello World e básico
Um programa Kotlin começa em uma função main de nível superior: nenhuma classe é necessária.
| Sintaxe | Significado |
|---|---|
fun main() { println("Hello") } | Ponto de entrada de um programa |
println("text") | Imprimir uma linha na saída padrão |
print("text") | Imprimir sem quebra de linha no final |
// comment | Comentário de uma linha |
/* comment */ | Comentário de várias linhas |
val input = readLine() | Ler uma linha do stdin (String? nullable) |
val line = readln() | Ler uma linha do stdin (não nulo, Kotlin 1.6+) |
Variáveis (val / var) e tipos
Prefira val; use var só quando o valor precisar mudar.
| Sintaxe | Significado |
|---|---|
val name = "Ada" | Variável somente leitura, tipo inferido como String |
var count = 0 | Variável mutável |
val age: Int = 30 | Anotação de tipo explícita |
Int, Long, Double, Float | Tipos numéricos (42, 42L, 3.14, 3.14f) |
Boolean, Char, String | true/false, 'a', "texto" |
val big = 1_000_000 | Underscores para literais legíveis |
"3".toInt(), "2.5".toDouble() | Converter uma string em número |
42.toString() | Número para string |
const val MAX = 10 | Constante em tempo de compilação (nível superior ou em um object) |
Strings e templates
Templates de string substituem a concatenação quase sempre.
| Sintaxe | Significado |
|---|---|
"Hi, $name" | Inserir uma variável em uma string |
"Total: ${price * qty}" | Inserir uma expressão |
s.length | Número de caracteres |
s.uppercase(), s.lowercase() | Mudar maiúsculas/minúsculas |
s.trim() | Remover espaços no início e no fim |
s.contains("x"), s.startsWith("a") | Buscar dentro de uma string |
s.substring(0, 3) | Fatiar por intervalo de índices |
s.split(",") | Dividir em uma List<String> |
s[0] | Caractere em um índice |
"""raw text""" | String bruta de várias linhas, sem escapes |
"%.2f".format(3.14159) | Saída formatada (3.14) |
Null safety
Um tipo é não nulo por padrão; adicione ? para permitir null e o compilador obriga você a tratá-lo.
| Sintaxe | Significado |
|---|---|
var s: String? = null | Tipo nullable |
s?.length | Chamada segura: retorna null se s for null |
s?.length ?: 0 | Operador Elvis: valor padrão quando for null |
s!!.length | Asserção de não nulo: lança exceção se s for null |
if (s != null) s.length | Smart cast para não nulo dentro da checagem |
s?.let { println(it) } | Executar um bloco só quando não for null |
val n = s?.toIntOrNull() | Converter, ou null se a entrada for inválida |
lateinit var x: String | Variável não nula inicializada depois |
Operadores
| Operador | Significado |
|---|---|
+ - * / % | Aritmética (/ entre Int é divisão inteira) |
+= -= *= /= %= | Atribuição composta |
++ -- | Incremento / decremento |
== != | Igualdade estrutural (chama equals) |
=== !== | Igualdade referencial (mesmo objeto) |
< > <= >= | Comparação |
&& || ! | E / ou / não lógicos |
a in 1..10 | Pertencimento a um range ou coleção |
x as Int, x as? Int | Cast / cast seguro (null se falhar) |
x is String | Checagem de tipo (smart cast se der certo) |
Controle de fluxo (if / when)
if e when são expressões: retornam um valor.
| Sintaxe | Significado |
|---|---|
if (a > b) x else y | if como expressão (Kotlin não tem ternário ?:) |
if (c) { ... } else if (d) { ... } else { ... } | Branches encadeados |
when (x) { 1 -> "one"; 2 -> "two"; else -> "other" } | Comparar com um valor |
when (x) { 1, 2 -> "low" } | Vários valores em um branch |
when (x) { in 1..9 -> "digit" } | Comparar com um range |
when (x) { is String -> x.length } | Comparar com um tipo (com smart cast) |
when { x < 0 -> "neg"; x == 0 -> "zero"; else -> "pos" } | when sem sujeito, como if/else if |
val label = when (x) { ... } | when como expressão (precisa de else) |
Loops e ranges
| Sintaxe | Significado |
|---|---|
for (i in 1..5) | Range inclusivo de 1 a 5 |
for (i in 1 until 5) | De 1 a 4 (fim exclusivo) |
for (i in 0..<5) | O mesmo com a sintaxe de range aberto (Kotlin 1.9+) |
for (i in 10 downTo 1 step 2) | Contar para trás em passos |
for (item in list) | Percorrer uma coleção |
for ((i, item) in list.withIndex()) | Índice e elemento juntos |
for (ch in "abc") | Percorrer os caracteres de uma string |
while (cond) { ... } | Repetir enquanto for verdadeiro |
do { ... } while (cond) | Executar pelo menos uma vez |
break, continue | Sair do loop / pular para a próxima iteração |
repeat(3) { println(it) } | Executar um bloco n vezes |
Funções
| Sintaxe | Significado |
|---|---|
fun add(a: Int, b: Int): Int { return a + b } | Declarar uma função |
fun add(a: Int, b: Int) = a + b | Função de uma expressão, tipo de retorno inferido |
fun greet(name: String = "world") | Valor padrão de parâmetro |
greet(name = "Ada") | Argumento nomeado |
fun log(vararg items: String) | Número variável de argumentos |
fun say(): Unit | Sem valor de retorno (Unit é opcional) |
val square = { x: Int -> x * x } | Lambda guardada em uma variável |
fun String.shout() = uppercase() + "!" | Função de extensão |
fun apply(f: (Int) -> Int) = f(2) | Função como parâmetro |
list.map { it * 2 } | Trailing lambda, it é o único parâmetro |
Listas
listOf é somente leitura; mutableListOf pode mudar.
| Sintaxe | Significado |
|---|---|
val nums = listOf(1, 2, 3) | Lista somente leitura |
val items = mutableListOf("a") | Lista mutável |
nums[0], nums.first(), nums.last() | Acessar elementos |
nums.getOrNull(9) | Acesso seguro, null se estiver fora do intervalo |
items.add("b"), items.remove("a") | Adicionar / remover |
items[0] = "z" | Substituir por índice |
nums.size, nums.isEmpty() | Tamanho e se está vazia |
x in nums, nums.contains(x) | Pertencimento |
nums.indexOf(2) | Posição de um elemento, -1 se não existir |
nums.subList(0, 2) | Sublista (fim exclusivo) |
nums.take(2), nums.drop(1) | Os primeiros n / todos menos os primeiros n |
nums.sorted(), nums.reversed() | Nova lista ordenada / invertida |
nums.sum(), nums.average(), nums.maxOrNull() | Agregações |
nums.joinToString(", ") | Juntar em uma única string |
Pair(1, "a"), 1 to "a", Triple(1, 2, 3) | Tuplas pequenas de tamanho fixo |
Maps e sets
| Sintaxe | Significado |
|---|---|
val m = mapOf("a" to 1, "b" to 2) | Map somente leitura |
val mm = mutableMapOf<String, Int>() | Map mutável |
m["a"] | Busca (null se não existir) |
m.getOrDefault("z", 0) | Busca com valor padrão |
mm["c"] = 3 | Inserir ou atualizar |
for ((k, v) in m) | Percorrer entradas com desestruturação |
m.keys, m.values | Coleções de chaves / valores |
"a" in m | Pertencimento de uma chave |
val s = setOf(1, 2, 2) | Set de valores únicos ({1, 2}) |
mutableSetOf<Int>() | Set mutável |
Operações em coleções (lambdas)
| Sintaxe | Significado |
|---|---|
list.map { it * 2 } | Transformar cada elemento |
list.filter { it > 2 } | Manter os elementos que satisfazem a condição |
list.forEach { println(it) } | Fazer algo com cada elemento |
list.any { it > 2 }, list.all { it > 0 } | Algum / todo elemento satisfaz a condição? |
list.count { it % 2 == 0 } | Contar correspondências |
list.find { it > 2 } | Primeira correspondência ou null |
list.sortedBy { it.length } | Ordenar por uma chave |
list.groupBy { it.first() } | Agrupar em um Map |
list.distinct() | Remover duplicatas |
list.fold(0) { acc, x -> acc + x } | Reduzir com um valor inicial |
list.zip(other) | Parear duas listas |
list.flatMap { it.toList() } | Mapear e depois achatar |
Classes e data classes
| Sintaxe | Significado |
|---|---|
class User(val name: String, var age: Int) | Classe com construtor primário e propriedades |
val u = User("Ada", 36) | Criar uma instância (sem new) |
u.name, u.age = 37 | Ler / escrever propriedades |
data class Point(val x: Int, val y: Int) | equals, hashCode, toString, copy de graça |
p.copy(y = 5) | Cópia com algumas propriedades alteradas |
val (x, y) = p | Declaração de desestruturação |
open class Base, class Sub : Base() | Herança (classes são final por padrão) |
override fun toString() = "..." | Sobrescrever um membro |
object Config { val debug = true } | Singleton |
companion object { fun create() = User("", 0) } | Membros do tipo estático |
enum class Color { RED, GREEN } | Enum |
sealed class Result | Hierarquia de classes restrita, exaustiva no when |
interface Shape { fun area(): Double } | Interface |
Tratamento de erros
| Sintaxe | Significado |
|---|---|
try { ... } catch (e: Exception) { ... } | Capturar uma exceção |
try { ... } finally { ... } | Sempre executar a limpeza |
val n = try { s.toInt() } catch (e: NumberFormatException) { 0 } | try como expressão |
throw IllegalArgumentException("bad") | Lançar uma exceção |
require(x > 0) { "x must be positive" } | Checagem de argumento (lança IllegalArgumentException) |
check(ready) { "not ready" } | Checagem de estado (lança IllegalStateException) |
s.toIntOrNull() | Retornar null em vez de lançar |
runCatching { risky() }.getOrDefault(0) | Envolver uma chamada em um Result |
Funções de escopo
Cinco pequenos auxiliares para trabalhar com um objeto dentro de um bloco.
| Sintaxe | Significado |
|---|---|
x.let { it + 1 } | it é o objeto, retorna o resultado do bloco |
x.run { this + 1 } | this é o objeto, retorna o resultado do bloco |
x.apply { field = 1 } | this é o objeto, retorna o objeto |
x.also { println(it) } | it é o objeto, retorna o objeto |
with(x) { field } | Não é uma extensão; this é x, retorna o resultado do bloco |
x?.let { ... } | A checagem de nulo idiomática + uso |
Toda a sintaxe de Kotlin que você procura, em uma única página. Este cheat sheet de Kotlin é uma referência rápida da linguagem por trás do Android e de boa parte da JVM moderna: declarar variáveis, lidar com nulos com segurança, ramificar com when, percorrer ranges, escrever funções e trabalhar com listas e maps.
Tudo aqui é Kotlin padrão e roda igual na JVM, no Android e com Kotlin Multiplatform. Copie o que precisar ou teste ao vivo no playground de Kotlin: cole um trecho, aperte Run e veja a saída no seu navegador.
Perguntas frequentes sobre o cheat sheet de Kotlin
Este cheat sheet de Kotlin é grátis?
Sim. Este cheat sheet de Kotlin é totalmente gratuito, sem cadastro. Salve nos favoritos e volte sempre que precisar consultar um branch de
when, um operador de null safety ou um método de coleção.Qual é a diferença entre val e var em Kotlin?
val declara uma referência somente leitura: é atribuída uma vez e não pode ser reatribuída. var declara uma variável mutável que pode ser reatribuída. Note que val só fixa a referência: uma val list = mutableListOf(1) ainda pode receber elementos. O estilo Kotlin é usar val em todo lugar e trocar para var só quando a reatribuição for realmente necessária.Como funciona o null safety em Kotlin?
Os tipos são não nulos por padrão, então
String nunca pode conter null; String? pode. O compilador não deixa você chamar um método em um valor nullable sem tratar o caso null: com uma chamada segura (s?.length), um fallback com Elvis (s?.length ?: 0), uma checagem de nulo com smart cast (if (s != null)) ou, como último recurso, a asserção de não nulo s!!, que lança NullPointerException se o valor for realmente null.Quando devo usar when em vez de if em Kotlin?
Use
when sempre que comparar um valor com várias possibilidades (constantes, ranges, tipos ou uma mistura) e use if/else para uma única condição de sim ou não. Ambos são expressões, então val label = when (x) { ... } e val label = if (c) a else b são idiomáticos. Um when usado como expressão precisa ser exaustivo, o que normalmente significa adicionar um branch else (sealed classes e enums podem ser exaustivos sem ele).Posso praticar Kotlin online?
Sim. Abra o playground de Kotlin para rodar qualquer trecho deste cheat sheet no navegador, sem instalar JDK ou IntelliJ. Quando quiser estrutura, o curso interativo e gratuito de Kotlin da Coddy leva você do Hello World até null safety,
when, loops, funções e coleções, e emite um certificado gratuito no final.Recursos relacionados
Mais folhas de consulta
