En este tema, exploraremos dos estructuras de datos fundamentales en Scala: los conjuntos (Sets) y los mapas (Maps). Estas estructuras son esenciales para manejar colecciones de datos de manera eficiente y son ampliamente utilizadas en la programación diaria.
Conjuntos (Sets)
Un conjunto es una colección de elementos únicos, es decir, no permite duplicados. Scala proporciona dos tipos principales de conjuntos: mutable
y immutable
. Por defecto, Scala utiliza conjuntos inmutables.
Creación de Conjuntos
// Conjunto inmutable val frutas = Set("manzana", "banana", "naranja") // Conjunto mutable import scala.collection.mutable val numeros = mutable.Set(1, 2, 3)
Operaciones Básicas con Conjuntos
-
Agregar Elementos:
// Inmutable val nuevasFrutas = frutas + "pera" // Mutable numeros += 4
-
Eliminar Elementos:
// Inmutable val menosFrutas = frutas - "banana" // Mutable numeros -= 2
-
Verificar Existencia de un Elemento:
val existeManzana = frutas.contains("manzana") // true val existeUva = frutas.contains("uva") // false
-
Operaciones de Conjuntos:
val conjuntoA = Set(1, 2, 3) val conjuntoB = Set(3, 4, 5) val union = conjuntoA | conjuntoB // Set(1, 2, 3, 4, 5) val interseccion = conjuntoA & conjuntoB // Set(3) val diferencia = conjuntoA &~ conjuntoB // Set(1, 2)
Ejercicio Práctico: Conjuntos
Ejercicio: Crea un conjunto de números enteros y realiza las siguientes operaciones:
- Agrega los números 4 y 5.
- Elimina el número 2.
- Verifica si el número 3 está en el conjunto.
- Encuentra la unión y la intersección con otro conjunto
{3, 6, 7}
.
Solución:
val numeros = Set(1, 2, 3) val nuevosNumeros = numeros + 4 + 5 val menosNumeros = nuevosNumeros - 2 val existeTres = menosNumeros.contains(3) val otroConjunto = Set(3, 6, 7) val union = menosNumeros | otroConjunto val interseccion = menosNumeros & otroConjunto println(s"Conjunto original: $numeros") println(s"Conjunto después de agregar 4 y 5: $nuevosNumeros") println(s"Conjunto después de eliminar 2: $menosNumeros") println(s"¿Existe el número 3? $existeTres") println(s"Unión: $union") println(s"Intersección: $interseccion")
Mapas (Maps)
Un mapa es una colección de pares clave-valor. Cada clave es única y se asocia con un valor. Al igual que los conjuntos, Scala proporciona mapas mutable
e immutable
.
Creación de Mapas
// Mapa inmutable val capitales = Map("Francia" -> "París", "Japón" -> "Tokio") // Mapa mutable import scala.collection.mutable val edades = mutable.Map("Juan" -> 30, "Ana" -> 25)
Operaciones Básicas con Mapas
-
Agregar o Actualizar Elementos:
// Inmutable val nuevasCapitales = capitales + ("España" -> "Madrid") // Mutable edades("Pedro") = 40 edades("Ana") = 26
-
Eliminar Elementos:
// Inmutable val menosCapitales = capitales - "Japón" // Mutable edades -= "Juan"
-
Acceder a Valores:
val capitalFrancia = capitales("Francia") // "París" val capitalItalia = capitales.getOrElse("Italia", "Desconocido") // "Desconocido"
-
Iterar sobre un Mapa:
for ((pais, capital) <- capitales) { println(s"La capital de $pais es $capital") }
Ejercicio Práctico: Mapas
Ejercicio: Crea un mapa de nombres y edades y realiza las siguientes operaciones:
- Agrega una nueva entrada para "Carlos" con edad 28.
- Actualiza la edad de "Ana" a 27.
- Elimina la entrada para "Juan".
- Verifica si "Pedro" está en el mapa y obtén su edad, si no está, devuelve "Desconocido".
Solución:
val edades = mutable.Map("Juan" -> 30, "Ana" -> 25) edades("Carlos") = 28 edades("Ana") = 27 edades -= "Juan" val edadPedro = edades.getOrElse("Pedro", "Desconocido") println(s"Mapa de edades: $edades") println(s"Edad de Pedro: $edadPedro")
Conclusión
En esta sección, hemos aprendido sobre dos estructuras de datos fundamentales en Scala: conjuntos y mapas. Hemos visto cómo crear, modificar y realizar operaciones básicas con estas colecciones. Los ejercicios prácticos proporcionados te ayudarán a consolidar tu comprensión y habilidades en el manejo de conjuntos y mapas en Scala.
En el próximo tema, exploraremos las tuplas y opciones, que son otras estructuras de datos útiles en Scala. ¡Sigue practicando y nos vemos en el siguiente módulo!
Curso de Programación en Scala
Módulo 1: Introducción a Scala
- Introducción a Scala
- Configuración del Entorno de Desarrollo
- Conceptos Básicos de Scala: Sintaxis y Estructura
- Variables y Tipos de Datos
- Operaciones Básicas y Expresiones
Módulo 2: Estructuras de Control y Funciones
- Sentencias Condicionales
- Bucles e Iteraciones
- Funciones y Métodos
- Funciones de Orden Superior
- Funciones Anónimas
Módulo 3: Colecciones y Estructuras de Datos
- Introducción a las Colecciones
- Listas y Arreglos
- Conjuntos y Mapas
- Tuplas y Opciones
- Coincidencia de Patrones
Módulo 4: Programación Orientada a Objetos en Scala
- Clases y Objetos
- Herencia y Rasgos
- Clases Abstractas y Clases Caso
- Objetos Compañeros
- Objetos Singleton
Módulo 5: Programación Funcional en Scala
- Inmutabilidad y Funciones Puras
- Estructuras de Datos Funcionales
- Mónadas y Funtores
- Comprensiones For
- Manejo de Errores en Programación Funcional
Módulo 6: Conceptos Avanzados de Scala
- Conversiones y Parámetros Implícitos
- Clases de Tipo y Polimorfismo
- Macros y Reflexión
- Concurrencia en Scala
- Introducción a Akka