Transformações
map, filter, flatMap.
Transformações é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
Transformando coleções
As coleções de Scala são imutáveis por padrão. Em vez de modificá-las, você as transforma em novas coleções usando métodos como map, filter e flatMap.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4)
val doubled = nums.map(_ * 2)
println(nums)
println(doubled)
}
}map: transformando cada elemento
map aplica uma função a cada elemento e retorna uma nova coleção com o mesmo tamanho. O tipo dos elementos pode mudar.
object Main {
def main(args: Array[String]): Unit = {
val words = List("scala", "rocks")
val lengths = words.map(_.length)
println(lengths)
}
}A forma abreviada com sublinhado
O sublinhado _ é uma forma abreviada de indicar um único parâmetro de função. _ * 2 significa x => x * 2. Isso mantém transformações simples compactas.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(10, 20, 30)
println(nums.map(_ + 1))
println(nums.map(x => x + 1))
}
}filter: mantendo elementos correspondentes
filter mantém apenas os elementos para os quais o predicado retorna true. O resultado pode ser menor que o original.
object Main {
def main(args: Array[String]): Unit = {
val nums = (1 to 10).toList
val evens = nums.filter(_ % 2 == 0)
println(evens)
}
}filterNot: o oposto
filterNot mantém os elementos para os quais o predicado é false. Ele é o complemento de filter.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4, 5)
println(nums.filterNot(_ % 2 == 0))
}
}flatMap: map e depois nivelar
flatMap aplica uma função que retorna uma coleção para cada elemento e, em seguida, nivela os resultados em uma única coleção.
object Main {
def main(args: Array[String]): Unit = {
val words = List("ab", "cd")
val chars = words.flatMap(_.toList)
println(chars)
}
}map versus flatMap
Se sua função retorna uma coleção, map fornece coleções aninhadas, enquanto flatMap fornece uma coleção plana. Escolha com base na estrutura desejada.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3)
println(nums.map(n => List(n, n)))
println(nums.flatMap(n => List(n, n)))
}
}flatMap com Option
flatMap sobre uma lista de Option descarta os valores None e extrai os valores Some, uma maneira prática de filtrar e transformar ao mesmo tempo.
object Main {
def main(args: Array[String]): Unit = {
val raw = List("1", "x", "3", "y")
val parsed = raw.flatMap(_.toIntOption)
println(parsed)
}
}collect: filtrando e aplicando map juntos
collect recebe uma função parcial: mantém e transforma apenas os elementos para os quais a função está definida, combinando filter e map em uma única passagem.
object Main {
def main(args: Array[String]): Unit = {
val mixed: List[Any] = List(1, "two", 3, "four", 5)
val ints = mixed.collect { case i: Int => i * 10 }
println(ints)
}
}Encadeando transformações
Como cada método retorna uma nova coleção, você pode encadeá-los em um pipeline legível. Cada etapa transforma a saída da etapa anterior.
object Main {
def main(args: Array[String]): Unit = {
val result = List(1, 2, 3, 4)
.map(_ + 1)
.filter(_ % 2 == 0)
println(result)
}
}Um pipeline limpo
Aqui está um pipeline de transformação organizado: filtrar números pares, elevá-los ao quadrado e então manter os maiores. Os pipelines são lidos como uma descrição do fluxo de dados.
object Main {
def main(args: Array[String]): Unit = {
val result = (1 to 10).toList
.filter(_ % 2 == 0)
.map(x => x * x)
.filter(_ > 10)
println(result)
}
}Verificação rápida
O que List("ab", "cd").flatMap(_.toList) retorna?
Recapitulação
Você aprendeu as transformações básicas:
map— transforma cada elemento, mantendo o mesmo tamanhofilter/filterNot— mantém ou descarta com base no predicadoflatMap— aplica map e depois nivela os resultados aninhadoscollect— filtra e aplica map com uma função parcial- Encadeie-as em pipelines legíveis e imutáveis
Perguntas Frequentes
A aula “Transformações” é grátis?
Sim — o texto completo de “Transformações” é 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Transformações”?
map, filter, flatMap. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 2 de 4.
Quanto tempo leva a aula “Transformações”?
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 Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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.