---
title: "Nullable em Kotlin: O que É e Como Funciona | Kotlin Brasil"
url: "https://kotlin.dev.br/glossario/nullable/"
markdown_url: "https://kotlin.dev.br/glossario/nullable.MD"
description: "Saiba o que são tipos Nullable em Kotlin, como lidar com null de forma segura e evitar NullPointerException."
date: "2026-02-08"
author: "Karina Melo"
---

# Nullable em Kotlin: O que É e Como Funciona | Kotlin Brasil

Saiba o que são tipos Nullable em Kotlin, como lidar com null de forma segura e evitar NullPointerException.


## O que é Nullable em Kotlin?

Em Kotlin, **todo tipo é não-nulo por padrão**. Se você declara uma variável como `String`, ela não pode receber `null`. Para permitir valores nulos, você precisa adicionar `?` ao tipo, criando um tipo **nullable** como `String?`.

Essa é uma das maiores sacadas do Kotlin: o famoso `NullPointerException` é praticamente eliminado em tempo de compilação.

### Declarando tipos nullable

```kotlin
var nome: String = "Karina"
// nome = null  // Erro de compilacao!

var apelido: String? = "Kah"
apelido = null  // Tudo certo!
```

### Operador de chamada segura `?.`

O operador `?.` só executa a operação se o valor não for nulo:

```kotlin
val cidade: String? = "São Paulo"
println(cidade?.length)    // 9

val estado: String? = null
println(estado?.length)    // null (nao dá erro!)
```

### Operador Elvis `?:`

O operador Elvis fornece um valor padrão quando o original é nulo:

```kotlin
val nome: String? = null
val exibicao = nome ?: "Anônimo"
println(exibicao) // Anônimo
```

Combina muito bem com o operador `?.`:

```kotlin
fun tamanhoDoNome(nome: String?): Int {
    return nome?.length ?: 0
}

println(tamanhoDoNome("Fernanda")) // 8
println(tamanhoDoNome(null))       // 0
```

### Operador de asserção `!!`

O `!!` força a conversão para não-nulo, mas lança exceção se o valor for `null`:

```kotlin
val valor: String? = "Kotlin"
println(valor!!.length) // 6

val nulo: String? = null
// println(nulo!!.length) // NullPointerException!
```

Use `!!` com muito cuidado — só quando você tem **certeza absoluta** de que o valor não é nulo.

### Smart cast com `if`

O Kotlin faz smart cast automaticamente após verificações de null:

```kotlin
fun imprimir(texto: String?) {
    if (texto != null) {
        // Aqui o compilador já sabe que texto nao é null
        println(texto.uppercase())
    }
}
```

### Encadeamento seguro com `let`

A função `let` combinada com `?.` é uma das formas mais elegantes de trabalhar com nullable:

```kotlin
data class Endereco(val rua: String?, val cidade: String?)
data class Usuario(val nome: String, val endereco: Endereco?)

fun exibirCidade(usuario: Usuario) {
    usuario.endereco?.cidade?.let { cidade ->
        println("O usuário mora em $cidade")
    } ?: println("Cidade nao informada")
}

fun main() {
    val usuario1 = Usuario("Ana", Endereco("Rua A", "Curitiba"))
    val usuario2 = Usuario("Pedro", null)

    exibirCidade(usuario1) // O usuário mora em Curitiba
    exibirCidade(usuario2) // Cidade nao informada
}
```

### Coleções e Nullable

Kotlin diferencia entre coleções que podem conter elementos nulos e coleções que podem ser nulas:

```kotlin
// Lista que pode conter elementos nulos
val nomes: List<String?> = listOf("Ana", null, "Carlos", null)
val naoNulos = nomes.filterNotNull()
println(naoNulos) // [Ana, Carlos]

// Lista que pode ser nula
val lista: List<String>? = null
println(lista?.size ?: 0) // 0

// Lista que pode ser nula E conter elementos nulos
val mista: List<String?>? = listOf("Kotlin", null, "Brasil")
val resultado = mista?.filterNotNull()?.joinToString()
println(resultado) // Kotlin, Brasil
```

### Casos de Uso no Mundo Real

- **Dados vindos de APIs externas**: respostas JSON frequentemente contêm campos opcionais. Usar tipos nullable permite modelar esses campos de forma segura sem arriscar crashes em tempo de execução.
- **Formulários de cadastro**: campos não obrigatórios como apelido, telefone secundário ou foto de perfil são naturalmente nullable na modelagem do domínio.
- **Integração com código Java**: bibliotecas Java podem retornar `null` em qualquer lugar. Os tipos nullable do Kotlin servem como camada de proteção nessa integração.
- **Busca em banco de dados**: consultas que podem não encontrar resultados retornam `null` naturalmente, como `findById()` que retorna `Usuario?`.

### Boas Práticas

- Prefira `?.` e `?:` em vez de `!!`. O operador `!!` deve ser a exceção, não a regra.
- Use `let` para trabalhar com nullable: `valor?.let { println(it) }`.
- Evite tipos nullable quando possível — menos `?`, menos problemas. Se um valor sempre vai existir, declare como não-nulo.
- Valide valores nullable nas bordas do sistema (entrada de dados, respostas de API) e converta para tipos não-nulos o mais cedo possível.
- Use `requireNotNull()` ou `checkNotNull()` para válidações explícitas com mensagens de erro descritivas, em vez de `!!`.

### Erros Comuns

- **Usar `!!` em toda parte**: isso destrói a segurança contra nulos do Kotlin. Cada `!!` é um potencial `NullPointerException` esperando para acontecer.
- **Ignorar avisos do compilador sobre platform types**: quando você usa código Java, o Kotlin mostra tipos como `String!` (platform type). Sempre trate esses tipos como nullable para evitar surpresas.
- **Criar cadeias longas de `?.`**: encadeamentos como `a?.b?.c?.d?.e` indicam que o modelo de dados pode estar mal estruturado. Considere refatorar.
- **Usar nullable para valores com default**: se um campo sempre tem um valor padrão, use esse valor em vez de `null`. Por exemplo, `val nome: String = ""` é melhor que `val nome: String? = null` quando string vazia é aceitável.
- **Esquecer de tratar o caso null**: usar apenas `?.` sem `?:` pode resultar em `null` silencioso propagando pelo sistema sem que ninguém perceba.

### Perguntas Frequentes

**Qual a diferença entre `String` e `String?` em Kotlin?** `String` é um tipo não-nulo que nunca pode receber `null`. `String?` é o tipo nullable equivalente, que aceita tanto valores de texto quanto `null`. O compilador trata os dois como tipos diferentes e exige operadores seguros ao trabalhar com `String?`.

**Quando devo usar `!!` em vez de `?.`?** Praticamente nunca. O `!!` deve ser usado apenas quando você tem garantia lógica absoluta de que o valor não é nulo e quer que o programa falhe caso esteja errado. Prefira `requireNotNull()` que permite incluir uma mensagem de erro explicativa.

**O Kotlin elimina completamente o NullPointerException?** Não completamente, mas reduz drasticamente. NPEs ainda podem ocorrer ao usar `!!`, ao interagir com código Java, ou em cenários de concorrência. A diferença é que, no Kotlin, quase todo NPE é uma escolha consciente do desenvolvedor.

**Como lidar com nullable em interoperabilidade com Java?** Trate todos os tipos vindos de Java como nullable por padrão, a menos que a biblioteca Java use anotações como `@NotNull` ou `@Nullable`. Use `?.` e `?:` para criar uma camada de segurança entre o código Kotlin e o Java.

### Termos Relacionados

- [Data Class](/glossario/data-class) — classes de dados que frequentemente contêm propriedades nullable
- [Scope Functions](/glossario/scope) — `let`, `run` e outras funções úteis para trabalhar com nullable
- [Smart Cast](/glossario/smart-cast) — conversão automática de tipos após verificações de null
- [Extension Function](/glossario/extension-function) — funções de extensão que podem ser declaradas para tipos nullable