Scala for Backend Engineering & Functional Programming · Aula

List, Vector, Set, Map

Coleções fundamentais.

List, Vector, Set, Map é uma aula grátis de Scala for Backend Engineering & Functional Programming 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 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.

As coleções básicas de Scala

Scala oferece várias coleções imutáveis em sua biblioteca padrão. As quatro que você mais usará são List, Vector, Set e Map. Cada uma tem desempenho e semântica diferentes.

object Main {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    val vector = Vector(1, 2, 3)
    val set = Set(1, 2, 3)
    val map = Map("a" -> 1, "b" -> 2)
    println(list)
    println(vector)
    println(set)
    println(map)
  }
}

List: uma lista encadeada

List é uma lista simplesmente encadeada. Adicionar no início com :: é O(1) e rápido, mas o acesso aleatório e a adição no final são O(n). Ela é ideal para recursão e uso como pilha.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(2, 3, 4)
    val prepended = 1 :: xs
    println(prepended)
    println("head: " + xs.head)
    println("tail: " + xs.tail)
  }
}

Vector: equilibrado e geral

Vector é uma sequência indexada com acesso, atualização, adição no início e adição no final efetivamente O(1). Quando você precisa de acesso aleatório rápido ou de uma sequência de uso geral, prefira Vector a List.

object Main {
  def main(args: Array[String]): Unit = {
    val v = Vector(10, 20, 30, 40)
    println(v(2))
    val updated = v.updated(0, 99)
    println(updated)
    println(v :+ 50)
  }
}

Set: elementos únicos

Um Set armazena elementos distintos, sem duplicatas e sem ordem garantida. Os testes de pertencimento com contains são rápidos.

object Main {
  def main(args: Array[String]): Unit = {
    val s = Set(1, 2, 2, 3, 3, 3)
    println(s)
    println(s.contains(2))
    println(s + 4)
    println(s - 1)
  }
}

Operações de Set

Os conjuntos oferecem operações matemáticas: union (|), intersect (&) e diff (−−).

object Main {
  def main(args: Array[String]): Unit = {
    val a = Set(1, 2, 3)
    val b = Set(2, 3, 4)
    println(a union b)
    println(a intersect b)
    println(a diff b)
  }
}

Map: pares de chave e valor

Um Map associa chaves a valores. As chaves são únicas. Crie entradas com a seta -> e consulte valores com get (que retorna Option) ou apply.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Ann" -> 30, "Bob" -> 25)
    println(ages("Ann"))
    println(ages.get("Cara"))
    println(ages.getOrElse("Cara", 0))
  }
}

Atualizando um Map imutavelmente

Mapas imutáveis retornam um mapa novo quando você adiciona ou remove entradas; o original permanece inalterado. Use + para adicionar ou substituir e - para remover.

object Main {
  def main(args: Array[String]): Unit = {
    val m = Map("a" -> 1)
    val m2 = m + ("b" -> 2)
    val m3 = m2 - "a"
    println(m)
    println(m2)
    println(m3)
  }
}

Iterando sobre um Map

Iterar sobre um Map fornece tuplas de chave e valor. Você pode separá-las diretamente em uma compreensão for ou com correspondência de padrões.

object Main {
  def main(args: Array[String]): Unit = {
    val scores = Map("math" -> 90, "art" -> 75)
    for ((subject, score) <- scores) {
      println(s"$subject: $score")
    }
  }
}

Métodos comuns compartilhados por todas

Todas essas coleções compartilham uma grande API comum: size, isEmpty, map, filter, foreach e muito mais. Aprenda a API uma vez e ela se aplicará a todas.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(1, 2, 3).map(_ * 2))
    println(Vector(1, 2, 3).map(_ * 2))
    println(Set(1, 2, 3).map(_ * 2))
  }
}

Convertendo entre coleções

Métodos de conversão como toList, toVector, toSet e toMap permitem trocar de tipo facilmente. Converter para um Set remove duplicatas.

object Main {
  def main(args: Array[String]): Unit = {
    val withDupes = List(1, 1, 2, 3, 3)
    println(withDupes.toSet)
    val pairs = List(("a", 1), ("b", 2))
    println(pairs.toMap)
  }
}

Escolhendo a coleção certa

Guia rápido:

List — recursão, adição rápida no início, processamento de cabeça/cauda
Vector — uso geral, acesso indexado rápido
Set — unicidade e testes de pertencimento
Map — consultas baseadas em chaves

object Main {
  def main(args: Array[String]): Unit = {
    val ids = List(5, 3, 5, 1, 3)
    val unique = ids.toSet
    val indexed = ids.toVector
    println(s"unique count: ${unique.size}")
    println(s"third element: ${indexed(2)}")
  }
}

Verificação rápida

Qual coleção remove automaticamente elementos duplicados?

Recapitulação

Você conheceu as principais coleções imutáveis de Scala:

List — lista encadeada, adição rápida no início
Vector — indexado, desempenho bem equilibrado
Set — elementos únicos com álgebra de conjuntos
Map — consultas de chave e valor com get/getOrElse

Elas compartilham uma API comum rica e são facilmente convertidas umas nas outras.

Perguntas Frequentes

A aula “List, Vector, Set, Map” é grátis?

Sim — o texto completo de “List, Vector, Set, Map” é 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 “List, Vector, Set, Map”?

Coleções fundamentais. 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 4.

Quanto tempo leva a aula “List, Vector, Set, Map”?

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