Profundización en colecciones inmutables
Explore colecciones inmutables fundamentales, como List, Map y Set, y aprenda a utilizarlas de forma eficiente.
Profundización en colecciones inmutables es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.
Colecciones inmutables: descripción general
¡Bienvenido a las colecciones inmutables! En Scala, son fundamentales para escribir código robusto, predecible y seguro en contextos de concurrencia, especialmente en la programación funcional.
Exploraremos tipos fundamentales como List, Map y Set, centrándonos en su uso eficiente y seguro.
Por qué es importante la inmutabilidad
La inmutabilidad significa que, una vez creada una colección, no se puede modificar. Cualquier operación que parezca «modificarla» en realidad devuelve una nueva colección.
- Previsibilidad: resulta más fácil razonar sobre el código.
- Seguridad de los hilos: no se necesitan bloqueos, ya que los datos nunca cambian.
- Ausencia de efectos secundarios: las operaciones no alterarán inesperadamente los datos en otras partes.
Listas de Scala: secuencias ordenadas
Una List en Scala es una secuencia inmutable y ordenada de elementos del mismo tipo. Es ideal para datos secuenciales en los que el orden es importante.
Puede crear una lista simplemente enumerando sus 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")
}
}Operaciones de List: head, tail y cons
Las listas ofrecen operaciones habituales, como obtener head (el primer elemento) y tail (el resto de la lista). El operador :: (cons) se utiliza para anteponer un elemento y crear una lista nueva.
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 de Scala: asociaciones clave-valor
Un Map es una colección inmutable que almacena pares clave-valor. Cada clave es única y se corresponde con un solo valor. Los mapas son excelentes para buscar valores mediante una clave 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")
}
}Operaciones de Map: acceso y actualización
Puede acceder a los valores de un Map mediante su clave. Para «actualizar» o «añadir» un par clave-valor, debe crear un mapa nuevo con los cambios, mientras que el mapa original permanece 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 de Scala: elementos únicos
Un Set es una colección inmutable de elementos únicos. A diferencia de las listas, el orden de los elementos de un conjunto no está garantizado y los elementos duplicados se ignoran automáticamente.
Los conjuntos son perfectos para comprobar la pertenencia o garantizar la unicidad.
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")
}
}Operaciones de Set: añadir, eliminar y unión
Al igual que las operaciones sobre List y Map, las operaciones sobre Set, como añadir o eliminar elementos, también devuelven un Set nuevo. También puede realizar operaciones de teoría de 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")
}
}Inmutabilidad: el original permanece
Es fundamental recordar que todas las operaciones de «modificación» sobre las colecciones inmutables de Scala devuelven una colección nueva. La colección original nunca cambia.
Este comportamiento es un pilar de la programación funcional en 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!
}
}Compruebe sus conocimientos
Considere el siguiente fragmento de código Scala:
val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2¿Cuál será el valor de mySet después de estas operaciones?
Repaso: colecciones inmutables
Ha explorado en profundidad las colecciones inmutables fundamentales de Scala:
- Listas: secuencias ordenadas, adecuadas para datos secuenciales.
- Mapas: pares clave-valor, eficientes para las búsquedas.
- Conjuntos: elementos únicos, ideales para comprobar la pertenencia.
La idea clave es la inmutabilidad: las operaciones siempre devuelven colecciones nuevas, lo que garantiza la previsibilidad y la seguridad.
Preguntas frecuentes
¿La lección «Profundización en colecciones inmutables» es gratis?
Sí — el texto completo de «Profundización en colecciones inmutables» 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 3 lecciones en total.
¿Qué aprenderé en «Profundización en colecciones inmutables»?
Explore colecciones inmutables fundamentales, como List, Map y Set, y aprenda a utilizarlas de forma eficiente. 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 3.
¿Cuánto tiempo toma la lección «Profundización en colecciones inmutables»?
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
- Profundización en colecciones inmutables
- Operaciones funcionales sobre colecciones
- Option, Try y Either para errores