--- title: "Collection Literals no Kotlin: Nova Sintaxe com Colchetes | Kotlin Brasil" url: "https://kotlin.dev.br/blog/collection-literals-kotlin-2026/" markdown_url: "https://kotlin.dev.br/blog/collection-literals-kotlin-2026.MD" description: "Conheça os collection literals do Kotlin 2.4.0: crie listas e mapas com sintaxe de colchetes []. Setup, exemplos práticos e migração." date: "2026-04-23" author: "Karina Melo" --- # Collection Literals no Kotlin: Nova Sintaxe com Colchetes | Kotlin Brasil Conheça os collection literals do Kotlin 2.4.0: crie listas e mapas com sintaxe de colchetes []. Setup, exemplos práticos e migração. Uma das features mais pedidas pela comunidade Kotlin finalmente está tomando forma. No **Kotlin 2.4.0-Beta2**, lançado em 22 de abril de 2026, a JetBrains introduziu os **collection literals** — uma nova sintaxe experimental que permite criar [coleções](/glossario/collections/) usando colchetes `[]`, similar ao que você já conhece em Python, JavaScript ou Swift. Se você acompanhou as [novidades do Kotlin 2.4.0 Beta](/blog/kotlin-2-4-0-beta-novidades-2026/), sabe que essa release veio carregada. Mas os collection literals são, na opinião de muitos devs, a mudança mais impactante no dia a dia de quem escreve Kotlin. ## O problema que os collection literals resolvem Hoje, para criar uma lista simples em Kotlin, você usa `listOf()`: ```kotlin val frutas = listOf("maçã", "banana", "laranja") val numeros = mutableListOf(1, 2, 3, 4, 5) val mapa = mapOf("chave" to "valor", "nome" to "Kotlin") ``` Funciona bem, mas é verboso comparado a outras linguagens. Em Python, seria `["maçã", "banana", "laranja"]`. Em JavaScript, a mesma coisa. O Kotlin sempre priorizou concisão — veja as [data classes](/glossario/data-class/), [scope functions](/blog/scope-functions-kotlin/) e [lambdas](/glossario/lambda/) — e os collection literals seguem essa filosofia. ## A nova sintaxe com colchetes Com collection literals habilitados, a mesma lista fica assim: ```kotlin val frutas = ["maçã", "banana", "laranja"] val numeros = [1, 2, 3, 4, 5] ``` Simples, limpo e direto. O compilador infere o tipo automaticamente — no caso acima, `List` e `List`, respectivamente. ### Tipo padrão é `List` (imutável) Quando você cria um literal sem declarar o tipo, o Kotlin infere como `List` imutável: ```kotlin val cores = ["vermelho", "azul", "verde"] // Tipo inferido: List ``` Para criar uma lista mutável, declare o tipo explicitamente: ```kotlin val coresMutaveis: MutableList = ["vermelho", "azul", "verde"] coresMutaveis.add("amarelo") // Funciona! ``` Isso é consistente com a filosofia do Kotlin de preferir [imutabilidade](/glossario/immutable/) por padrão — se você quer algo mutável, precisa ser explícito. ### Usando com tipos específicos Você pode declarar o tipo desejado e o compilador se adapta: ```kotlin val listaImutavel: List = [1, 2, 3] val listaMutavel: MutableList = [1, 2, 3] val conjunto: Set = ["kotlin", "java", "scala"] val conjuntoMutavel: MutableSet = ["kotlin", "java"] ``` Note que a sintaxe `[]` funciona para `List`, `MutableList`, `Set` e `MutableSet`. Para mapas, a sintaxe é um pouco diferente — veremos adiante. ## Collection literals em parâmetros de função Onde os collection literals realmente brilham é em chamadas de função. Compare o antes e depois: ### Antes (Kotlin atual) ```kotlin fun processarPedido(itens: List, prioridades: Set) { // lógica } processarPedido( itens = listOf("Notebook", "Mouse", "Teclado"), prioridades = setOf(1, 2, 3) ) ``` ### Depois (com collection literals) ```kotlin processarPedido( itens = ["Notebook", "Mouse", "Teclado"], prioridades = [1, 2, 3] // inferido como Set pelo tipo do parâmetro ) ``` O compilador usa o tipo do parâmetro da função para decidir se deve criar uma `List` ou um `Set`. Isso elimina a necessidade de chamar `listOf()` ou `setOf()` em toda chamada de função. Esse pattern fica especialmente útil em [DSLs](/glossario/dsl/) e configurações com [Kotlin DSL no Gradle](/tutoriais/kotlin-gradle-tutorial/), onde listas de dependências e configurações são comuns. ## Collection literals e annotations Uma área onde collection literals fazem diferença imediata é em annotations: ```kotlin @Suppress(["UNCHECKED_CAST", "DEPRECATION"]) fun minhaFuncao() { // ... } @Target([AnnotationTarget.CLASS, AnnotationTarget.FUNCTION]) annotation class MinhaAnnotation ``` Até agora, o Kotlin usava `arrayOf()` em annotations — os collection literals oferecem uma alternativa mais limpa. ## Combinando com outras features do Kotlin ### Com when expressions Os collection literals combinam naturalmente com o [when](/glossario/when/) do Kotlin: ```kotlin fun classificarFruta(fruta: String): String = when (fruta) { in ["maçã", "pera", "uva"] -> "Fruta temperada" in ["manga", "abacaxi", "mamão"] -> "Fruta tropical" in ["morango", "framboesa", "mirtilo"] -> "Fruta vermelha" else -> "Fruta desconhecida" } ``` ### Com destructuring Combinado com [destructuring](/glossario/destructuring/), fica ainda mais expressivo: ```kotlin val (primeiro, segundo, terceiro) = ["Kotlin", "Java", "Scala"] println("Preferida: $primeiro") // Preferida: Kotlin ``` ### Com higher-order functions A integração com [higher-order functions](/glossario/higher-order-function/) e o ecossistema de [collections](/tutoriais/collections-kotlin/) é natural: ```kotlin val resultado = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] .filter { it % 2 == 0 } .map { it * it } .sum() println(resultado) // 220 ``` ## Como habilitar collection literals Como essa feature é **experimental** no Kotlin 2.4.0-Beta2, você precisa habilitar explicitamente. Adicione no `build.gradle.kts`: ```kotlin kotlin { compilerOptions { freeCompilerArgs.add("-Xsupport-collection-literals") } } ``` Ou, se preferir habilitar por arquivo, use a annotation: ```kotlin @file:OptIn(ExperimentalCollectionLiterals::class) ``` Lembre-se: como é experimental, a API pode mudar até atingir o status estável. Para projetos em produção, avalie o risco. Para projetos pessoais e protótipos, vale experimentar desde já. Se você usa [Gradle Version Catalogs](/blog/gradle-version-catalog-kotlin-2026/) no projeto, atualize a versão do Kotlin no `libs.versions.toml`: ```toml [versions] kotlin = "2.4.0-Beta2" ``` ## Impacto na legibilidade do código Vamos comparar um cenário mais realista — configuração de um cliente HTTP com [Ktor](/tutoriais/kotlin-ktor-tutorial/): ### Antes ```kotlin val config = HttpClientConfig( headers = mapOf( "Content-Type" to "application/json", "Accept" to "application/json" ), retryStatusCodes = listOf(503, 429, 502), allowedMethods = setOf("GET", "POST", "PUT", "DELETE") ) ``` ### Depois ```kotlin val config = HttpClientConfig( headers = mapOf( "Content-Type" to "application/json", "Accept" to "application/json" ), retryStatusCodes = [503, 429, 502], allowedMethods = ["GET", "POST", "PUT", "DELETE"] ) ``` A diferença parece sutil em exemplos pequenos, mas em bases de código grandes — especialmente em [testes unitários](/tutoriais/kotlin-testes-unitarios/) com muitos dados de entrada — a economia de digitação e a clareza visual são significativas. ## O que ainda falta Apesar do avanço, alguns pontos ainda estão em discussão pela equipe do Kotlin: - **Map literals**: ainda não há sintaxe literal para mapas. Você continua usando `mapOf("chave" to "valor")`. A comunidade está debatendo opções como `["chave": "valor"]` ou `{"chave": "valor"}` - **Array literals**: a sintaxe atual não cobre arrays primitivos (`IntArray`, `ByteArray`, etc.) - **Inferência em contextos complexos**: em alguns cenários com [generics](/glossario/generics/) avançados, a inferência pode exigir type annotations explícitas ## Collection literals vs. outras linguagens | Linguagem | Lista | Mapa | |-----------|-------|------| | Kotlin (novo) | `[1, 2, 3]` | `mapOf(1 to "a")` | | Python | `[1, 2, 3]` | `{1: "a"}` | | Swift | `[1, 2, 3]` | `[1: "a"]` | | JavaScript | `[1, 2, 3]` | `{1: "a"}` | | Java | `List.of(1, 2, 3)` | `Map.of(1, "a")` | O Kotlin está se alinhando com a sintaxe que desenvolvedores de outras linguagens já conhecem, reduzindo a curva de aprendizado. Se você veio do Python ou JavaScript e está [aprendendo Kotlin](/perguntas/como-aprender-kotlin/), essa sintaxe vai parecer familiar. ## Quando usar e quando evitar **Use collection literals quando:** - Criar listas/sets inline em chamadas de função - Escrever testes com dados de exemplo - Configurar [DSLs](/blog/kotlin-dsl/) e builders - Inicializar constantes simples **Evite por enquanto quando:** - O projeto precisa de estabilidade máxima (ainda é experimental) - Você precisa de arrays primitivos para performance - O time ainda não está no Kotlin 2.4+ ## Conclusão Os collection literals são uma adição natural e bem-vinda ao Kotlin. A sintaxe com colchetes é mais concisa, mais familiar para quem vem de outras linguagens, e se integra perfeitamente com o sistema de tipos do Kotlin. Se você já programa em Python, vai notar que a sintaxe `[1, 2, 3]` é praticamente idêntica — e essa familiaridade é intencional. Mesmo sendo experimental, vale a pena começar a experimentar em projetos pessoais e acompanhar a evolução para a versão estável. Com o [Kotlin 2.4.0](/blog/kotlin-2-4-0-beta-novidades-2026/) trazendo também [context parameters estáveis](/blog/kotlin-context-receivers-parameters/), [explicit backing fields](/glossario/property-delegate/) e melhorias no [Kotlin/Wasm](/blog/kotlin-wasm-novidades/), o ecossistema continua evoluindo em ritmo forte. Se você está começando com Kotlin, confira nosso [guia completo](/guias/guia-completo-kotlin/) e o [tutorial de variáveis e tipos](/tutoriais/variaveis-e-tipos/) para entender a base antes de mergulhar em features avançadas. E para ficar por dentro de todas as novidades, acompanhe nosso [blog](/blog/) e a seção de [tendências Kotlin 2026](/blog/tendencias-kotlin-2026/). --- ## Perguntas Frequentes ### Os collection literals já podem ser usados em produção? Não, os collection literals ainda são **experimentais** no Kotlin 2.4.0-Beta2. A API pode mudar antes de atingir o status estável. Use em projetos pessoais e protótipos por enquanto, e aguarde a estabilização antes de adotar em produção. ### Qual a diferença entre `[1, 2, 3]` e `listOf(1, 2, 3)`? Funcionalmente, nenhuma. O compilador traduz `[1, 2, 3]` para o mesmo bytecode que `listOf(1, 2, 3)`. A diferença é puramente sintática — os collection literals oferecem uma escrita mais concisa e familiar. ### Posso criar mapas com collection literals? Ainda não. Na versão atual, os collection literals suportam `List`, `MutableList`, `Set` e `MutableSet`. A sintaxe para mapas ainda está sendo discutida pela equipe do Kotlin. Por enquanto, continue usando `mapOf()`. ### Preciso atualizar o Kotlin para usar collection literals? Sim, você precisa do **Kotlin 2.4.0-Beta2 ou superior** e habilitar a flag experimental `-Xsupport-collection-literals` no compilador. Também funciona com a annotation `@file:OptIn(ExperimentalCollectionLiterals::class)` por arquivo.