Verdieping in immutable collecties
Verken fundamentele immutable collecties zoals List, Map en Set en leer hoe u deze efficiënt gebruikt.
Verdieping in immutable collecties is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Scala voor backend-engineering en functioneel programmeren. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 3 lessen.
Overzicht van onveranderlijke verzamelingen
Welkom bij onveranderlijke verzamelingen! In Scala vormen ze de basis voor het schrijven van robuuste, gelijktijdige en voorspelbare code, vooral bij functioneel programmeren.
We verkennen fundamentele typen zoals List, Map en Set, met de nadruk op efficiënt en veilig gebruik.
Waarom onveranderlijkheid belangrijk is
Onveranderlijkheid betekent dat een verzameling na het maken niet meer kan worden gewijzigd. Elke bewerking die de verzameling lijkt te 'wijzigen', geeft in werkelijkheid een nieuwe verzameling terug.
- Voorspelbaarheid: Code is eenvoudiger te begrijpen.
- Threadveiligheid: Vergrendelingen zijn niet nodig omdat de gegevens nooit veranderen.
- Geen neveneffecten: Bewerkingen wijzigen niet onverwacht gegevens elders.
Scala-lijsten: geordende reeksen
Een List in Scala is een onveranderlijke, geordende reeks elementen van hetzelfde type. Deze is ideaal voor opeenvolgende gegevens waarbij de volgorde belangrijk is.
Je maakt een lijst door de elementen eenvoudig op te sommen.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(1, 2, 3, 4, 5)
val fruits = List("apple", "banana", "cherry")
println(s"Numbers list: $numbers")
println(s"Fruits list: $fruits")
}
}Lijstbewerkingen: head, tail en cons
Lijsten bieden veelgebruikte bewerkingen, zoals het ophalen van de head (het eerste element) en de tail (de rest van de lijst). De operator :: (cons) wordt gebruikt om een element vooraan toe te voegen, waarbij een nieuwe lijst ontstaat.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(10, 20, 30)
println(s"Original list: $numbers")
println(s"Head of list: ${numbers.head}") // 10
println(s"Tail of list: ${numbers.tail}") // List(20, 30)
val newList = 5 :: numbers // Prepend 5
println(s"List with 5 prepended: $newList")
}
}Scala-maps: sleutel-waardeassociaties
Een Map is een onveranderlijke verzameling waarin sleutel-waardeparen worden opgeslagen. Elke sleutel is uniek en verwijst naar één waarde. Maps zijn uitstekend geschikt om waarden op basis van een specifieke sleutel op te zoeken.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
val codes = Map(1 -> "One", 2 -> "Two")
println(s"Ages map: $ages")
println(s"Codes map: $codes")
}
}Map-bewerkingen: toegang en bijwerken
Je kunt waarden in een Map openen met de bijbehorende sleutel. Als je een sleutel-waardepaar wilt 'bijwerken' of toevoegen, maak je een nieuwe map met de wijzigingen, terwijl de oorspronkelijke map ongewijzigd blijft.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25)
println(s"Original ages: $ages")
println(s"Bob's age: ${ages("Bob")}")
val updatedAges = ages + ("Charlie" -> 35) // Add new pair
println(s"Ages after adding Charlie: $updatedAges")
val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
println(s"Ages after updating Alice: $changedAges")
}
}Scala-sets: unieke elementen
Een Set is een onveranderlijke verzameling unieke elementen. In tegenstelling tot lijsten is de volgorde van elementen in een Set niet gegarandeerd en worden dubbele elementen automatisch genegeerd.
Sets zijn perfect om te controleren of een element aanwezig is of om uniciteit te garanderen.
object Main {
def main(args: Array[String]): Unit = {
val numbers = Set(1, 2, 2, 3, 4, 3, 5)
val letters = Set('a', 'b', 'a')
println(s"Unique numbers: $numbers")
println(s"Unique letters: $letters")
}
}Set-bewerkingen: toevoegen, verwijderen en unie
Net als bewerkingen op lijsten en maps geven bewerkingen op sets, zoals elementen toevoegen of verwijderen, ook een nieuwe Set terug. Je kunt ook verzamelingenleerbewerkingen uitvoeren, zoals union (sets combineren).
object Main {
def main(args: Array[String]): Unit = {
val setA = Set(1, 2, 3)
val setB = Set(3, 4, 5)
println(s"Set A: $setA")
println(s"Set B: $setB")
val addedSet = setA + 4 // Add element
println(s"Set A + 4: $addedSet")
val removedSet = setA - 2 // Remove element
println(s"Set A - 2: $removedSet")
val unionSet = setA union setB // Combine sets
println(s"Set A union Set B: $unionSet")
}
}Onveranderlijkheid: het origineel blijft behouden
Het is belangrijk om te onthouden dat alle 'wijzigingsbewerkingen' op de onveranderlijke verzamelingen van Scala een nieuwe verzameling teruggeven. De oorspronkelijke verzameling wordt nooit gewijzigd.
Dit gedrag vormt een hoeksteen van functioneel programmeren in Scala.
object Main {
def main(args: Array[String]): Unit = {
val originalList = List(10, 20, 30)
println(s"Original List: $originalList")
val doubledList = originalList.map(_ * 2) // map returns a NEW list
println(s"List after map: $doubledList")
println(s"Original list is still: $originalList") // Unchanged!
}
}Controleer je begrip
Bekijk het volgende stukje Scala-code:
val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2Wat is na deze bewerkingen de waarde van mySet?
Samenvatting: onveranderlijke verzamelingen
Je hebt de fundamentele onveranderlijke verzamelingen van Scala uitgebreid verkend:
- Lijsten: geordende reeksen, geschikt voor opeenvolgende gegevens.
- Maps: sleutel-waardeparen, efficiënt voor opzoekingen.
- Sets: unieke elementen, uitstekend voor controles op aanwezigheid.
De belangrijkste conclusie is onveranderlijkheid: bewerkingen geven altijd nieuwe verzamelingen terug, wat voorspelbaarheid en veiligheid garandeert.
Leer Scala met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 143
Veelgestelde vragen
Is de les “Verdieping in immutable collecties” gratis?
Ja — de volledige tekst van “Verdieping in immutable collecties” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Scala voor backend-engineering en functioneel programmeren wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Scala voor backend-engineering en functioneel programmeren bevat in totaal 3 lessen.
Wat leer ik in “Verdieping in immutable collecties”?
Verken fundamentele immutable collecties zoals List, Map en Set en leer hoe u deze efficiënt gebruikt. Je oefent met Scala voor backend-engineering en functioneel programmeren door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Scala voor backend-engineering en functioneel programmeren te beginnen?
Ervaring vooraf is niet nodig. Scala voor backend-engineering en functioneel programmeren op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Verdieping in immutable collecties”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Scala voor backend-engineering en functioneel programmeren?
Ja. Elke les over Scala voor backend-engineering en functioneel programmeren bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Verdieping in immutable collecties
- Functionele bewerkingen op collecties
- Option, Try en Either voor fouten