0Pricing
Kotlin Academy · Aula

map e flatMap: transformando cada elemento

Transforme coleções com map e achate resultados aninhados com flatMap.

map e flatMap: transformando cada elemento é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Noções básicas de transformação

map aplica uma função a cada elemento e retorna uma nova coleção do mesmo tamanho. flatMap faz o mesmo, mas transforma listas de listas em uma única lista.

map básico

Transforme cada elemento com uma lambda; o resultado tem o mesmo tamanho da entrada.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val squares = nums.map { it * it }
    println(squares) // [1, 4, 9, 16]
}

map altera o tipo

O tipo dos elementos de saída pode ser diferente do tipo dos elementos de entrada — List<Int> pode se tornar List<String>.

fun main() {
    val nums = listOf(1, 2, 3)
    val labels = nums.map { "Item $it" }
    println(labels)
}

map em uma classe de dados

Extraia uma propriedade de cada elemento — transforme classes de dados em tipos mais simples.

data class User(val name: String, val age: Int)
fun main() {
    val users = listOf(User("Ada", 35), User("Ben", 22))
    val names = users.map { it.name }
    println(names) // [Ada, Ben]
}

Encadeamento de chamadas map

Várias chamadas de map são compostas naturalmente — cada uma transforma a saída da anterior.

fun main() {
    val nums = listOf(1, 2, 3)
    val result = nums.map { it + 1 }.map { it * 10 }
    println(result) // [20, 30, 40]
}

flatMap básico

flatMap chama uma função que retorna uma lista para cada elemento e depois achata todos os resultados em uma única lista.

fun main() {
    val words = listOf("hello", "world")
    val chars = words.flatMap { it.toList() }
    println(chars) // [h, e, l, l, o, w, o, r, l, d]
}

Quando usar flatMap

Use flatMap quando a lambda produzir naturalmente uma lista e você quiser um único resultado plano em vez de uma lista de listas.

data class Order(val items: List<String>)
fun main() {
    val orders = listOf(
        Order(listOf("pen", "book")),
        Order(listOf("lamp")),
        Order(listOf("mug", "ring"))
    )
    val allItems = orders.flatMap { it.items }
    println(allItems) // [pen, book, lamp, mug, ring]
}

map de lista versus flatMap

Compare os tipos de resultado — map mantém o aninhamento, enquanto flatMap o remove.

fun main() {
    val nums = listOf(1, 2, 3)
    val mapped = nums.map { listOf(it, it * 10) }
    val flat = nums.flatMap { listOf(it, it * 10) }
    println(mapped) // [[1, 10], [2, 20], [3, 30]]
    println(flat)   // [1, 10, 2, 20, 3, 30]
}

flatMap com listas condicionais

Retorne listas vazias para os elementos que deseja descartar — flatMap filtra e transforma em uma única etapa.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)
    val doubled = nums.flatMap { if (it % 2 == 0) listOf(it, it * 2) else emptyList() }
    println(doubled) // [2, 4, 4, 8]
}

map com índice

mapIndexed fornece o índice e o valor à lambda.

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    val labeled = fruits.mapIndexed { i, name -> "$i: $name" }
    println(labeled)
}

Sequence versus lista

Para cadeias muito longas, converta primeiro para uma Sequence para evitar a criação de listas intermediárias.

fun main() {
    val big = (1..100).asSequence()
        .map { it + 1 }
        .filter { it % 5 == 0 }
        .map { it * 2 }
        .toList()
    println(big.take(5)) // first 5 results
}

Verificação rápida

Qual é a principal diferença entre map e flatMap?

Recapitulação

map transforma cada elemento (mantém o tamanho, mas pode gerar um novo tipo). flatMap aplica uma função que retorna uma lista e depois concatena todos os resultados. Combine-a com mapIndexed para obter índices e use Sequence em cadeias longas e lentas.

Perguntas Frequentes

A aula “map e flatMap: transformando cada elemento” é grátis?

Sim — o texto completo de “map e flatMap: transformando cada elemento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “map e flatMap: transformando cada elemento”?

Transforme coleções com map e achate resultados aninhados com flatMap. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “map e flatMap: transformando cada elemento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. map e flatMap: transformando cada elemento
  2. filter, filterNot e partition
  3. fold, reduce e runningFold
  4. Encadeando pipelines e evitando listas intermediárias com Sequence
← Voltar para Kotlin Academy