Scala voor backend-engineering en functioneel programmeren · Les

List, Vector, Set, Map

Kerncollecties

Les 1 van 413 stappen

List, Vector, Set, Map is een gratis Scala voor backend-engineering en functioneel programmeren-les op CoddyKit. Dit is les 1 van 4. 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 4 lessen.

De kerncollecties van Scala

Scala biedt verschillende onveranderlijke collecties in de standaardbibliotheek. De vier die je het vaakst zult gebruiken zijn List, Vector, Set en Map. Elk type heeft andere prestatiekenmerken en semantiek.

object Main {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3)
    val vector = Vector(1, 2, 3)
    val set = Set(1, 2, 3)
    val map = Map("a" -> 1, "b" -> 2)
    println(list)
    println(vector)
    println(set)
    println(map)
  }
}

List: een gekoppelde lijst

List is een enkelvoudig gekoppelde lijst. Voorvoegen met :: kost O(1) en is snel, maar willekeurige toegang en achteraan toevoegen kosten O(n). Het type is ideaal voor recursie en gebruik als stack.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(2, 3, 4)
    val prepended = 1 :: xs
    println(prepended)
    println("head: " + xs.head)
    println("tail: " + xs.tail)
  }
}

Vector: gebalanceerd en algemeen inzetbaar

Vector is een geïndexeerde sequentie met effectief O(1) voor toegang, bijwerken, voorvoegen en achteraan toevoegen. Als je snelle willekeurige toegang of een algemene sequentie nodig hebt, gebruik je liever Vector dan List.

object Main {
  def main(args: Array[String]): Unit = {
    val v = Vector(10, 20, 30, 40)
    println(v(2))
    val updated = v.updated(0, 99)
    println(updated)
    println(v :+ 50)
  }
}

Set: unieke elementen

Een Set bevat unieke elementen, zonder duplicaten en zonder gegarandeerde volgorde. Lidmaatschapscontroles met contains zijn snel.

object Main {
  def main(args: Array[String]): Unit = {
    val s = Set(1, 2, 2, 3, 3, 3)
    println(s)
    println(s.contains(2))
    println(s + 4)
    println(s - 1)
  }
}

Bewerkingen op sets

Sets ondersteunen wiskundige bewerkingen: union (|), intersect (&) en diff (−−).

object Main {
  def main(args: Array[String]): Unit = {
    val a = Set(1, 2, 3)
    val b = Set(2, 3, 4)
    println(a union b)
    println(a intersect b)
    println(a diff b)
  }
}

Map: sleutel-waardeparen

Een Map koppelt sleutels aan waarden. Sleutels zijn uniek. Maak items met de pijl -> en zoek waarden op met get (geeft Option terug) of apply.

object Main {
  def main(args: Array[String]): Unit = {
    val ages = Map("Ann" -> 30, "Bob" -> 25)
    println(ages("Ann"))
    println(ages.get("Cara"))
    println(ages.getOrElse("Cara", 0))
  }
}

Een Map onveranderlijk bijwerken

Onveranderlijke maps geven een nieuwe map terug wanneer je items toevoegt of verwijdert; het origineel blijft ongewijzigd. Gebruik + om iets toe te voegen of te overschrijven en - om iets te verwijderen.

object Main {
  def main(args: Array[String]): Unit = {
    val m = Map("a" -> 1)
    val m2 = m + ("b" -> 2)
    val m3 = m2 - "a"
    println(m)
    println(m2)
    println(m3)
  }
}

Door een Map itereren

Als je over een Map itereert, krijg je sleutel-waardetuples. Je kunt ze rechtstreeks destructureren in een for-comprehension of met pattern matching.

object Main {
  def main(args: Array[String]): Unit = {
    val scores = Map("math" -> 90, "art" -> 75)
    for ((subject, score) <- scores) {
      println(s"$subject: $score")
    }
  }
}

Veelgebruikte methoden die ze allemaal delen

Al deze collecties delen een uitgebreide algemene API: size, isEmpty, map, filter, foreach en meer. Leer de API één keer en je kunt die overal toepassen.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(1, 2, 3).map(_ * 2))
    println(Vector(1, 2, 3).map(_ * 2))
    println(Set(1, 2, 3).map(_ * 2))
  }
}

Tussen collecties converteren

Met conversiemethoden zoals toList, toVector, toSet en toMap kun je eenvoudig van type wisselen. Converteren naar een Set verwijdert duplicaten.

object Main {
  def main(args: Array[String]): Unit = {
    val withDupes = List(1, 1, 2, 3, 3)
    println(withDupes.toSet)
    val pairs = List(("a", 1), ("b", 2))
    println(pairs.toMap)
  }
}

De juiste collectie kiezen

Snelle handleiding:

List — recursie, snel voorvoegen, head/tail-verwerking
Vector — algemeen inzetbaar, snelle geïndexeerde toegang
Set — uniciteit en lidmaatschapscontroles
Map — op sleutels gebaseerde zoekopdrachten

object Main {
  def main(args: Array[String]): Unit = {
    val ids = List(5, 3, 5, 1, 3)
    val unique = ids.toSet
    val indexed = ids.toVector
    println(s"unique count: ${unique.size}")
    println(s"third element: ${indexed(2)}")
  }
}

Korte controle

Welke collectie verwijdert automatisch dubbele elementen?

Beantwoord dit in de interactieve les

Samenvatting

Je hebt kennisgemaakt met de belangrijkste onveranderlijke collecties van Scala:

List — gekoppelde lijst, snel voorvoegen
Vector — geïndexeerd, goed gebalanceerde prestaties
Set — unieke elementen met verzamelingenalgebra
Map — op sleutels gebaseerde zoekopdrachten met get/getOrElse

Ze delen een uitgebreide algemene API en kunnen eenvoudig in elkaar worden omgezet.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “List, Vector, Set, Map” gratis?

Ja — de volledige tekst van “List, Vector, Set, Map” 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 4 lessen.

Wat leer ik in “List, Vector, Set, Map”?

Kerncollecties 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 4.

Hoe lang duurt de les “List, Vector, Set, Map”?

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

← Terug naar Scala voor backend-engineering en functioneel programmeren