El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Estructures de Dades Funcionals

Següent ►
►

En aquest tema, explorarem les estructures de dades funcionals en Scala. Les estructures de dades funcionals són immutables per naturalesa, la qual cosa significa que no es poden modificar després de la seva creació. Això proporciona molts avantatges, com ara la seguretat en concurrència i la facilitat de raonament sobre el codi.

Objectius del Tema

  • Entendre la importància de les estructures de dades immutables.
  • Aprendre sobre les estructures de dades funcionals més comunes en Scala.
  • Implementar i utilitzar aquestes estructures de dades en exemples pràctics.

Conceptes Clau

  1. Immutabilitat

  • Definició: Una estructura de dades immutable no es pot modificar després de la seva creació.
  • Avantatges:
    • Seguretat en concurrència: No cal preocupar-se per les condicions de carrera.
    • Facilitat de raonament: El codi és més fàcil de seguir i depurar.
    • Històric de versions: Es poden mantenir versions anteriors de les dades fàcilment.

  1. Llistes Immutables

  • Definició: Una llista immutable és una seqüència ordenada d'elements que no es pot modificar.
  • Exemple: 
    val llista = List(1, 2, 3)
val novaLlista = 0 :: llista // Prepend 0 to the list
println(novaLlista) // Output: List(0, 1, 2, 3)

  1. Mapes Immutables

  • Definició: Un mapa immutable és una col·lecció de parelles clau-valor que no es pot modificar.
  • Exemple: 
    val mapa = Map("a" -> 1, "b" -> 2)
val nouMapa = mapa + ("c" -> 3)
println(nouMapa) // Output: Map(a -> 1, b -> 2, c -> 3)

  1. Sets Immutables

  • Definició: Un set immutable és una col·lecció d'elements únics que no es pot modificar.
  • Exemple: 
    val set = Set(1, 2, 3)
val nouSet = set + 4
println(nouSet) // Output: Set(1, 2, 3, 4)

Exemples Pràctics

Exemple 1: Treballant amb Llistes Immutables

val llista = List(1, 2, 3, 4, 5)

// Afegir un element al principi de la llista
val novaLlista = 0 :: llista
println(novaLlista) // Output: List(0, 1, 2, 3, 4, 5)

// Afegir un element al final de la llista
val llistaAmbElementAfegit = llista :+ 6
println(llistaAmbElementAfegit) // Output: List(1, 2, 3, 4, 5, 6)

Exemple 2: Treballant amb Mapes Immutables

val mapa = Map("a" -> 1, "b" -> 2)

// Afegir una nova parella clau-valor
val nouMapa = mapa + ("c" -> 3)
println(nouMapa) // Output: Map(a -> 1, b -> 2, c -> 3)

// Actualitzar un valor existent
val mapaActualitzat = mapa + ("a" -> 10)
println(mapaActualitzat) // Output: Map(a -> 10, b -> 2)

Exemple 3: Treballant amb Sets Immutables

val set = Set(1, 2, 3)

// Afegir un nou element
val nouSet = set + 4
println(nouSet) // Output: Set(1, 2, 3, 4)

// Intentar afegir un element duplicat (no canvia el set)
val setAmbDuplicat = set + 3
println(setAmbDuplicat) // Output: Set(1, 2, 3)

Exercicis Pràctics

Exercici 1: Treballant amb Llistes Immutables

Crea una llista immutable de números del 1 al 5. Afegeix el número 0 al principi i el número 6 al final. Imprimeix la llista resultant.

Solució

val llista = List(1, 2, 3, 4, 5)
val novaLlista = 0 :: llista :+ 6
println(novaLlista) // Output: List(0, 1, 2, 3, 4, 5, 6)

Exercici 2: Treballant amb Mapes Immutables

Crea un mapa immutable amb les parelles clau-valor ("x" -> 24, "y" -> 25). Afegeix una nova parella ("z" -> 26) i actualitza el valor de "x" a 42. Imprimeix el mapa resultant.

Solució

val mapa = Map("x" -> 24, "y" -> 25)
val nouMapa = mapa + ("z" -> 26) + ("x" -> 42)
println(nouMapa) // Output: Map(x -> 42, y -> 25, z -> 26)

Exercici 3: Treballant amb Sets Immutables

Crea un set immutable amb els elements 1, 2 i 3. Afegeix el número 4 i intenta afegir el número 2 de nou. Imprimeix el set resultant.

Solució

val set = Set(1, 2, 3)
val nouSet = set + 4 + 2
println(nouSet) // Output: Set(1, 2, 3, 4)

Resum

En aquest tema, hem après sobre les estructures de dades funcionals en Scala, incloent llistes, mapes i sets immutables. Hem vist com aquestes estructures de dades proporcionen avantatges com la seguretat en concurrència i la facilitat de raonament. També hem treballat amb exemples pràctics i exercicis per reforçar els conceptes apresos. En el proper tema, explorarem les monads i els functors, conceptes clau en la programació funcional.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats