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

Conjunts i Mapes

Següent ►
►

En aquest tema, explorarem dues col·leccions fonamentals en Scala: els conjunts (sets) i els mapes (maps). Aquestes estructures de dades són essencials per a la manipulació eficient de dades i són àmpliament utilitzades en la programació diària.

Conjunts (Sets)

Què és un Conjunt?

Un conjunt és una col·lecció no ordenada d'elements únics. Això significa que no pot contenir elements duplicats. Els conjunts són útils quan necessitem garantir la unicitat dels elements.

Tipus de Conjunts

Scala proporciona dues implementacions principals de conjunts:

  • scala.collection.immutable.Set: Conjunt immutable.
  • scala.collection.mutable.Set: Conjunt mutable.

Creació de Conjunts

Conjunt Immutable

val fruits = Set("apple", "banana", "cherry")
println(fruits) // Output: Set(apple, banana, cherry)

Conjunt Mutable

import scala.collection.mutable

val mutableFruits = mutable.Set("apple", "banana", "cherry")
println(mutableFruits) // Output: Set(apple, banana, cherry)

Operacions amb Conjunts

Afegir Elements

  • Immutable Set: Retorna un nou conjunt amb l'element afegit.
val newFruits = fruits + "orange"
println(newFruits) // Output: Set(apple, banana, cherry, orange)
  • Mutable Set: Modifica el conjunt existent.
mutableFruits += "orange"
println(mutableFruits) // Output: Set(apple, banana, cherry, orange)

Eliminar Elements

  • Immutable Set: Retorna un nou conjunt amb l'element eliminat.
val lessFruits = fruits - "banana"
println(lessFruits) // Output: Set(apple, cherry)
  • Mutable Set: Modifica el conjunt existent.
mutableFruits -= "banana"
println(mutableFruits) // Output: Set(apple, cherry, orange)

Verificar Existència d'un Element

println(fruits.contains("apple")) // Output: true
println(fruits.contains("grape")) // Output: false

Operacions de Conjunt

  • Unió: Combina dos conjunts.
val set1 = Set(1, 2, 3)
val set2 = Set(3, 4, 5)
val unionSet = set1 union set2
println(unionSet) // Output: Set(1, 2, 3, 4, 5)
  • Intersecció: Troba els elements comuns entre dos conjunts.
val intersectSet = set1 intersect set2
println(intersectSet) // Output: Set(3)
  • Diferència: Troba els elements que estan en el primer conjunt però no en el segon.
val diffSet = set1 diff set2
println(diffSet) // Output: Set(1, 2)

Mapes (Maps)

Què és un Map?

Un map és una col·lecció de parelles clau-valor. Cada clau és única i està associada a un valor. Els mapes són útils per emmagatzemar dades on cada element té una clau única.

Tipus de Mapes

Scala proporciona dues implementacions principals de mapes:

  • scala.collection.immutable.Map: Map immutable.
  • scala.collection.mutable.Map: Map mutable.

Creació de Mapes

Map Immutable

val countryCodes = Map("US" -> "United States", "FR" -> "France", "ES" -> "Spain")
println(countryCodes) // Output: Map(US -> United States, FR -> France, ES -> Spain)

Map Mutable

import scala.collection.mutable

val mutableCountryCodes = mutable.Map("US" -> "United States", "FR" -> "France", "ES" -> "Spain")
println(mutableCountryCodes) // Output: Map(US -> United States, FR -> France, ES -> Spain)

Operacions amb Mapes

Afegir o Actualitzar Elements

  • Immutable Map: Retorna un nou map amb l'element afegit o actualitzat.
val newCountryCodes = countryCodes + ("DE" -> "Germany")
println(newCountryCodes) // Output: Map(US -> United States, FR -> France, ES -> Spain, DE -> Germany)
  • Mutable Map: Modifica el map existent.
mutableCountryCodes += ("DE" -> "Germany")
println(mutableCountryCodes) // Output: Map(US -> United States, FR -> France, ES -> Spain, DE -> Germany)

Eliminar Elements

  • Immutable Map: Retorna un nou map amb l'element eliminat.
val lessCountryCodes = countryCodes - "FR"
println(lessCountryCodes) // Output: Map(US -> United States, ES -> Spain)
  • Mutable Map: Modifica el map existent.
mutableCountryCodes -= "FR"
println(mutableCountryCodes) // Output: Map(US -> United States, ES -> Spain, DE -> Germany)

Accedir a Elements

println(countryCodes("US")) // Output: United States
println(countryCodes.getOrElse("IT", "Not Found")) // Output: Not Found

Iterar sobre un Map

for ((code, country) <- countryCodes) {
  println(s"Code: $code, Country: $country")
}
// Output:
// Code: US, Country: United States
// Code: FR, Country: France
// Code: ES, Country: Spain

Exercicis Pràctics

Exercici 1: Conjunts

Crea un conjunt immutable de números enters i realitza les següents operacions:

  1. Afegeix el número 10 al conjunt.
  2. Elimina el número 5 del conjunt.
  3. Verifica si el número 3 està present al conjunt.

Solució

val numbers = Set(1, 2, 3, 4, 5)
val newNumbers = numbers + 10
val lessNumbers = newNumbers - 5
val containsThree = lessNumbers.contains(3)

println(newNumbers) // Output: Set(1, 2, 3, 4, 5, 10)
println(lessNumbers) // Output: Set(1, 2, 3, 4, 10)
println(containsThree) // Output: true

Exercici 2: Mapes

Crea un map mutable de noms de persones i les seves edats. Realitza les següents operacions:

  1. Afegeix una nova persona amb el nom "Alice" i l'edat 30.
  2. Actualitza l'edat de "Bob" a 25.
  3. Elimina la persona amb el nom "Charlie".

Solució

import scala.collection.mutable

val people = mutable.Map("Bob" -> 20, "Charlie" -> 35)
people += ("Alice" -> 30)
people("Bob") = 25
people -= "Charlie"

println(people) // Output: Map(Bob -> 25, Alice -> 30)

Conclusió

En aquesta secció, hem après sobre els conjunts i els mapes en Scala, incloent-hi com crear-los, modificar-los i accedir-hi. Aquestes estructures de dades són fonamentals per a la manipulació eficient de dades i són àmpliament utilitzades en la programació diària. En el proper tema, explorarem les tuples i les opcions, que són altres estructures de dades importants en Scala.

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