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

  1. Agregar Elementos:

    // Inmutable
    val nuevasFrutas = frutas + "pera"
    
    // Mutable
    numeros += 4
    
  2. Eliminar Elementos:

    // Inmutable
    val menosFrutas = frutas - "banana"
    
    // Mutable
    numeros -= 2
    
  3. Verificar Existencia de un Elemento:

    val existeManzana = frutas.contains("manzana") // true
    val existeUva = frutas.contains("uva") // false
    
  4. 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:

  1. Agrega los números 4 y 5.
  2. Elimina el número 2.
  3. Verifica si el número 3 está en el conjunto.
  4. 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

  1. Agregar o Actualizar Elementos:

    // Inmutable
    val nuevasCapitales = capitales + ("España" -> "Madrid")
    
    // Mutable
    edades("Pedro") = 40
    edades("Ana") = 26
    
  2. Eliminar Elementos:

    // Inmutable
    val menosCapitales = capitales - "Japón"
    
    // Mutable
    edades -= "Juan"
    
  3. Acceder a Valores:

    val capitalFrancia = capitales("Francia") // "París"
    val capitalItalia = capitales.getOrElse("Italia", "Desconocido") // "Desconocido"
    
  4. 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:

  1. Agrega una nueva entrada para "Carlos" con edad 28.
  2. Actualiza la edad de "Ana" a 27.
  3. Elimina la entrada para "Juan".
  4. 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!

© Copyright 2024. Todos los derechos reservados