Scala for Backend Engineering & Functional Programming · Lección

List, Vector, Set, Map

Colecciones principales

List, Vector, Set, Map es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Las colecciones principales de Scala

Scala ofrece varias colecciones inmutables en su biblioteca estándar. Las cuatro que utilizará con más frecuencia son List, Vector, Set y Map. Cada una tiene características de rendimiento y 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: una lista enlazada

List es una lista simplemente enlazada. Anteponer elementos con :: es O(1) y rápido, pero el acceso aleatorio y añadir elementos al final son operaciones O(n). Es ideal para la recursión y para usarla como una pila.

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 y general

Vector es una secuencia indexada cuyo acceso, actualización, inserción al principio y adición al final son efectivamente operaciones O(1). Cuando necesite un acceso aleatorio rápido o una secuencia de propósito general, prefiera 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

Un Set almacena elementos distintos, sin duplicados y sin un orden garantizado. Las comprobaciones de pertenencia con contains son rápidas.

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)
  }
}

Operaciones con Set

Los conjuntos admiten operaciones matemáticas: union (|), intersect (&) y 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 clave-valor

Un Map asocia claves con valores. Las claves son únicas. Cree entradas con la flecha -> y busque valores con get (que devuelve Option) o 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))
  }
}

Actualizar un Map de forma inmutable

Los mapas inmutables devuelven un mapa nuevo al añadir o eliminar entradas; el original no cambia. Use + para añadir o sobrescribir y - para eliminar.

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)
  }
}

Iterar sobre un Map

Iterar sobre un Map proporciona tuplas de clave y valor. Puede desestructurarlas directamente en una for-comprehension o mediante coincidencia de patrones.

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 comunes a todas

Todas estas colecciones comparten una API común amplia: size, isEmpty, map, filter, foreach y muchos más. Aprenda la API una vez y podrá aplicarla en cualquier colección.

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))
  }
}

Convertir entre colecciones

Los métodos de conversión, como toList, toVector, toSet y toMap, le permiten cambiar de tipo fácilmente. Convertir a un Set elimina los duplicados.

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)
  }
}

Elegir la colección adecuada

Guía rápida:

List — recursión, inserción rápida al principio y procesamiento de cabeza y cola
Vector — propósito general y acceso indexado rápido
Set — unicidad y comprobaciones de pertenencia
Map — búsquedas basadas en claves

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)}")
  }
}

Comprobación rápida

¿Qué colección elimina automáticamente los elementos duplicados?

Resumen

Ha conocido las colecciones inmutables principales de Scala:

List — lista enlazada, inserción rápida al principio
Vector — acceso indexado y rendimiento equilibrado
Set — elementos únicos y álgebra de conjuntos
Map — búsquedas de valores por clave con get/getOrElse

Comparten una API común completa y se convierten fácilmente unas en otras.

Preguntas frecuentes

¿La lección «List, Vector, Set, Map» es gratis?

Sí — el texto completo de «List, Vector, Set, Map» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «List, Vector, Set, Map»?

Colecciones principales Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «List, Vector, Set, Map»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming