Scala for Backend Engineering & Functional Programming · Aula

Mergulho profundo em coleções imutáveis

Explore coleções imutáveis fundamentais, como List, Map e Set, e aprenda a utilizá-las com eficiência.

Mergulho profundo em coleções imutáveis é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

Coleções imutáveis: visão geral

Boas-vindas às coleções imutáveis! Em Scala, elas são fundamentais para escrever código robusto, concorrente e previsível, especialmente na programação funcional.

Vamos explorar tipos fundamentais como List, Map e Set, com foco no uso eficiente e seguro deles.

Por que a imutabilidade é importante

Imutabilidade significa que, depois que uma coleção é criada, ela não pode ser alterada. Qualquer operação que pareça 'modificá-la' na verdade retorna uma nova coleção.

Previsibilidade: é mais fácil compreender o código.
Segurança entre threads: não há necessidade de bloqueios, pois os dados nunca mudam.
Ausência de efeitos colaterais: as operações não alterarão dados em outro local inesperadamente.

Listas em Scala: sequências ordenadas

Uma List em Scala é uma sequência imutável e ordenada de elementos do mesmo tipo. Ela é ideal para dados sequenciais em que a ordem é importante.

Você pode criar uma lista simplesmente enumerando seus elementos.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5)
    val fruits = List("apple", "banana", "cherry")
    println(s"Numbers list: $numbers")
    println(s"Fruits list: $fruits")
  }
}

Operações com listas: início, cauda e cons

As listas oferecem operações comuns, como obter o head (primeiro elemento) e o tail (restante da lista). O operador :: (cons) é usado para adicionar um elemento no início, criando uma nova lista.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(10, 20, 30)
    println(s"Original list: $numbers")
    println(s"Head of list: ${numbers.head}") // 10
    println(s"Tail of list: ${numbers.tail}") // List(20, 30)
    val newList = 5 :: numbers // Prepend 5
    println(s"List with 5 prepended: $newList")
  }
}

Mapas em Scala: associações entre chave e valor

Um Map é uma coleção imutável que armazena pares de chave e valor. Cada chave é única e corresponde a um único valor. Os mapas são excelentes para consultar valores por uma chave específica.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
    val codes = Map(1 -> "One", 2 -> "Two")
    println(s"Ages map: $ages")
    println(s"Codes map: $codes")
  }
}

Operações com mapas: acesso e atualização

Você pode acessar valores em um Map usando sua chave. Para 'atualizar' ou 'adicionar' um par de chave e valor, crie um novo mapa com as alterações, deixando o mapa original intacto.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Alice" -> 30, "Bob" -> 25)
    println(s"Original ages: $ages")
    println(s"Bob's age: ${ages("Bob")}")
    val updatedAges = ages + ("Charlie" -> 35) // Add new pair
    println(s"Ages after adding Charlie: $updatedAges")
    val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
    println(s"Ages after updating Alice: $changedAges")
  }
}

Conjuntos em Scala: elementos únicos

Um Set é uma coleção imutável de elementos únicos. Diferentemente das listas, a ordem dos elementos em um Set não é garantida, e elementos duplicados são ignorados automaticamente.

Os conjuntos são perfeitos para verificar pertencimento ou garantir unicidade.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = Set(1, 2, 2, 3, 4, 3, 5)
    val letters = Set('a', 'b', 'a')
    println(s"Unique numbers: $numbers")
    println(s"Unique letters: $letters")
  }
}

Operações com conjuntos: adicionar, remover e união

Assim como nas listas e nos mapas, as operações de adicionar ou remover elementos de conjuntos também retornam um novo Set. Você também pode realizar operações da teoria dos conjuntos, como union (combinar conjuntos).

object Main {
  def main(args: Array[String]): Unit = {
    val setA = Set(1, 2, 3)
    val setB = Set(3, 4, 5)
    println(s"Set A: $setA")
    println(s"Set B: $setB")
    val addedSet = setA + 4 // Add element
    println(s"Set A + 4: $addedSet")
    val removedSet = setA - 2 // Remove element
    println(s"Set A - 2: $removedSet")
    val unionSet = setA union setB // Combine sets
    println(s"Set A union Set B: $unionSet")
  }
}

Imutabilidade: o original permanece

É fundamental lembrar que todas as operações de 'modificação' nas coleções imutáveis do Scala retornam uma nova coleção. A coleção original nunca é alterada.

Esse comportamento é um dos pilares da programação funcional em Scala.

object Main {
  def main(args: Array[String]): Unit = {
    val originalList = List(10, 20, 30)
    println(s"Original List: $originalList")
    val doubledList = originalList.map(_ * 2) // map returns a NEW list
    println(s"List after map: $doubledList")
    println(s"Original list is still: $originalList") // Unchanged!
  }
}

Verifique sua compreensão

Considere o seguinte trecho de código Scala:

val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2

Qual será o valor de mySet depois dessas operações?

Recapitulação: coleções imutáveis

Você explorou detalhadamente as coleções imutáveis fundamentais do Scala:

Listas: sequências ordenadas, adequadas para dados sequenciais.
Mapas: pares de chave e valor, eficientes para consultas.
Conjuntos: elementos únicos, ótimos para verificar pertencimento.

A principal conclusão é a imutabilidade: as operações sempre retornam novas coleções, garantindo previsibilidade e segurança.

Perguntas Frequentes

A aula “Mergulho profundo em coleções imutáveis” é grátis?

Sim — o texto completo de “Mergulho profundo em coleções imutáveis” é 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 3 aulas no total.

O que vou aprender em “Mergulho profundo em coleções imutáveis”?

Explore coleções imutáveis fundamentais, como List, Map e Set, e aprenda a utilizá-las com eficiência. 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 1 de 3.

Quanto tempo leva a aula “Mergulho profundo em coleções imutáveis”?

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.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming