El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Estructuras de Datos Funcionales

Siguiente ►
►

En este tema, exploraremos las estructuras de datos funcionales en Scala. Las estructuras de datos funcionales son inmutables y están diseñadas para trabajar de manera eficiente en un entorno funcional. Aprenderemos sobre las principales estructuras de datos funcionales disponibles en Scala y cómo utilizarlas.

Objetivos del Tema

  • Comprender la importancia de la inmutabilidad en las estructuras de datos funcionales.
  • Conocer las principales estructuras de datos funcionales en Scala.
  • Aprender a utilizar listas, conjuntos y mapas inmutables.
  • Implementar operaciones comunes en estas estructuras de datos.

  1. Inmutabilidad en Estructuras de Datos

¿Qué es la Inmutabilidad?

La inmutabilidad significa que una vez que una estructura de datos se ha creado, no puede ser modificada. En lugar de modificar una estructura de datos existente, se crea una nueva estructura con los cambios aplicados.

Ventajas de la Inmutabilidad

  • Seguridad en concurrencia: Las estructuras de datos inmutables son intrínsecamente seguras para el acceso concurrente.
  • Facilidad de razonamiento: Es más fácil razonar sobre el estado del programa cuando las estructuras de datos no cambian.
  • Evita efectos secundarios: La inmutabilidad ayuda a evitar efectos secundarios no deseados, lo que es crucial en la programación funcional.

  1. Listas Inmutables

Definición y Uso

Las listas inmutables son una de las estructuras de datos más comunes en Scala. Se definen utilizando la clase List.

val lista: List[Int] = List(1, 2, 3, 4, 5)

Operaciones Comunes

  • Acceso a elementos: Puedes acceder a los elementos de una lista utilizando el índice.
val primerElemento = lista(0) // 1
  • Añadir elementos: Para añadir elementos, se crea una nueva lista.
val nuevaLista = 0 :: lista // List(0, 1, 2, 3, 4, 5)
  • Concatenar listas: Puedes concatenar dos listas utilizando el operador ++.
val otraLista = List(6, 7, 8)
val listaConcatenada = lista ++ otraLista // List(1, 2, 3, 4, 5, 6, 7, 8)

Ejercicio Práctico

Ejercicio: Crea una lista de números del 1 al 10 y realiza las siguientes operaciones:

  1. Accede al tercer elemento.
  2. Añade el número 0 al inicio de la lista.
  3. Concatenar la lista con otra lista de números del 11 al 15.

Solución:

val lista = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val tercerElemento = lista(2) // 3
val listaConCero = 0 :: lista // List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val otraLista = List(11, 12, 13, 14, 15)
val listaConcatenada = lista ++ otraLista // List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

  1. Conjuntos Inmutables

Definición y Uso

Los conjuntos inmutables se definen utilizando la clase Set.

val conjunto: Set[Int] = Set(1, 2, 3, 4, 5)

Operaciones Comunes

  • Añadir elementos: Para añadir elementos, se crea un nuevo conjunto.
val nuevoConjunto = conjunto + 6 // Set(1, 2, 3, 4, 5, 6)
  • Eliminar elementos: Para eliminar elementos, se crea un nuevo conjunto.
val conjuntoSinTres = conjunto - 3 // Set(1, 2, 4, 5)
  • Unión de conjuntos: Puedes unir dos conjuntos utilizando el operador ++.
val otroConjunto = Set(6, 7, 8)
val conjuntoUnido = conjunto ++ otroConjunto // Set(1, 2, 3, 4, 5, 6, 7, 8)

Ejercicio Práctico

Ejercicio: Crea un conjunto de números del 1 al 5 y realiza las siguientes operaciones:

  1. Añade el número 6 al conjunto.
  2. Elimina el número 3 del conjunto.
  3. Une el conjunto con otro conjunto de números del 7 al 9.

Solución:

val conjunto = Set(1, 2, 3, 4, 5)
val conjuntoConSeis = conjunto + 6 // Set(1, 2, 3, 4, 5, 6)
val conjuntoSinTres = conjunto - 3 // Set(1, 2, 4, 5)
val otroConjunto = Set(7, 8, 9)
val conjuntoUnido = conjunto ++ otroConjunto // Set(1, 2, 3, 4, 5, 7, 8, 9)

  1. Mapas Inmutables

Definición y Uso

Los mapas inmutables se definen utilizando la clase Map.

val mapa: Map[String, Int] = Map("a" -> 1, "b" -> 2, "c" -> 3)

Operaciones Comunes

  • Acceso a valores: Puedes acceder a los valores utilizando las claves.
val valorA = mapa("a") // 1
  • Añadir pares clave-valor: Para añadir pares clave-valor, se crea un nuevo mapa.
val nuevoMapa = mapa + ("d" -> 4) // Map("a" -> 1, "b" -> 2, "c" -> 3, "d" -> 4)
  • Eliminar pares clave-valor: Para eliminar pares clave-valor, se crea un nuevo mapa.
val mapaSinB = mapa - "b" // Map("a" -> 1, "c" -> 3)

Ejercicio Práctico

Ejercicio: Crea un mapa con las claves "x", "y" y "z" con valores 10, 20 y 30 respectivamente, y realiza las siguientes operaciones:

  1. Accede al valor de la clave "y".
  2. Añade un nuevo par clave-valor ("w", 40).
  3. Elimina el par clave-valor con la clave "x".

Solución:

val mapa = Map("x" -> 10, "y" -> 20, "z" -> 30)
val valorY = mapa("y") // 20
val nuevoMapa = mapa + ("w" -> 40) // Map("x" -> 10, "y" -> 20, "z" -> 30, "w" -> 40)
val mapaSinX = mapa - "x" // Map("y" -> 20, "z" -> 30)

Conclusión

En esta sección, hemos aprendido sobre las estructuras de datos funcionales en Scala, incluyendo listas, conjuntos y mapas inmutables. Hemos visto cómo estas estructuras de datos promueven la inmutabilidad y cómo realizar operaciones comunes en ellas. La inmutabilidad es un concepto clave en la programación funcional y nos ayuda a escribir código más seguro y fácil de mantener.

En el próximo tema, exploraremos las mónadas y los funtores, conceptos avanzados que nos permitirán manejar efectos secundarios de manera funcional y elegante.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados