Lijsten in Scala

Leer wat lijsten zijn en hoe je ze kunt benutten in de programmeertaal Scala.

Bijgewerkt 2 okt 2026 · 6 min lezen

Verken met AI

Misschien vind je de volgende tutorials ook interessant:

Introductie

Bron: Wikipedia - List (abstract data type)

Een enkelvoudig gekoppelde lijststructuur, die een lijst met 3 gehele elementen implementeert (Bron: Wikipedia - List (abstract data type)).

Een lijst is in het algemeen een reeks abstracte gegevenstypen die een vast aantal waarden vertegenwoordigen. Waarden kunnen programmatisch worden gemanipuleerd door een programma en kunnen ook meer dan eens in een lijst voorkomen. Een instantie van een lijst wordt in de bovenstaande afbeelding getoond als een enkelvoudig gekoppelde lijst bestaande uit drie geheelgetallen. De lijst wordt ook beschouwd als een datastructuur; een voorbeeld daarvan is de gelinkte lijst.

Veel programmeertalen bieden ondersteuning voor lijsten; een voorbeeld waarin mensen lijsten uitgebreid gebruiken is Python. Een lijst kan vaak worden geconstrueerd door de items in een reeks te schrijven, gescheiden door komma's, puntkomma's of spaties, binnen een paar begrenzers zoals ronde haken (), vierkante haken [], accolades {} of punthaken <>. Sommige talen zoals Python staan toe dat lijsttypen worden geïndexeerd of gesliced zoals arraytypen; in dat geval wordt het gegevenstype nauwkeuriger beschreven als een array (Bron: Wikipedia - List (abstract data type)).

Specifiek voor Scala is een lijst een collectie die immutable data bevat, wat betekent dat, zodra de lijst is gemaakt, deze niet kan worden gewijzigd. In Scala vertegenwoordigt de lijst een gelinkte lijst.

In een Scala-lijst hoeft elk element niet van hetzelfde gegevenstype te zijn. De implementatie van Scala-lijsten gebruikt intern een muteerbare staat tijdens de constructiefase. In Scala is de lijst gedefinieerd onder het pakket scala.collection.immutable en is dus immutable. Tot slot heeft een Scala List verschillende methoden zoals add, prepend, max, min, enz.

Syntaxis voor het definiëren van een Scala List

val variable_name: List[type] = List(item1, item2, item3) of val variable_name = List(item1, item2, item3) Een lijst in Scala lijkt grotendeels op een Scala-array. De Scala List is echter immutable en vertegenwoordigt een gelinkte lijst-datastructuur. De Scala-array daarentegen is vlak en muteerbaar.

Laten we het bovenstaande verschil snel begrijpen met behulp van een voorbeeld.

Scala List vs. Scala Array

Laten we eerst een array in Scala definiëren.

Vervolgens wijzig je een waarde op de 1e index, aangezien Scala-arrays nulgebaseerd zijn, en kijk je of je deze kunt bijwerken.

Zoals je in bovenstaande codefragment kunt zien, stond de Scala-array toe dat je de waarde op de 1e index wijzigde.

Nu definieer je een Scala List en probeer je hetzelfde als hierboven na te bootsen.

Uit het bovenstaande voorbeeld kun je concluderen dat, omdat Scala Lists immutable zijn, het bijwerken van de waarde tot een fout leidde.

Scala List-methoden

head: Deze methode geeft het eerste element van de Scala-lijst terug.
tail: Deze methode geeft alle elementen behalve het eerste terug.
isEmpty: Deze methode controleert of de lijst leeg is; in dat geval geeft hij True terug, anders False.
fill(): Deze methode maakt een uniforme lijst die bestaat uit nul of meer kopieën van het opgegeven element.
reverse: Deze methode keert de elementen van de lijst om.
$:::$ of $.:::$ of .concat(): Concateneert twee of meer lijsten.
tabulate(): Met deze methode kun je een lijst tabuleren. Het lijkt qua idee op de methode fill(), maar in tegenstelling tot fill() neemt hij twee argumenten. Het eerste argument geeft de dimensies van de te maken lijst, terwijl het tweede de elementen van de lijst beschrijft, die worden berekend vanuit een functie.

Maak je geen zorgen als sommige van de bovenstaande methoden nog niet veel voor je betekenen; je gaat ze zo in Scala implementeren met behulp van een voorbeeld. Maar eerst: hoe definieer je Scala Lists?

Je maakt Scala Lists met de gegevenstypen strings, integers (zowel 1D als 2D). Je leert ook een lijst te maken die zowel strings als integers bevat.

1D-integerlijst

1D-lijst met zowel integer als string

1D-stringlijst

2D-lijst

Rekenkundige bewerkingen op lijsten

In dit voorbeeld maak je gebruik van lijsten in plaats van alleen variabelen te definiëren. In tegenstelling tot een variabele kan een List n waarden bevatten; je voert de rekenkundige bewerkingen uit op de twee lijsten in plaats van op twee variabelen.

Laten we snel bekijken hoe je dat doet.

Om de rekenkundige bewerkingen toe te passen, maak je gebruik van de functie zipped.map, gevolgd door de lijsten x en y. Vervolgens geef je in de methode zipped.map als argument de bewerking op die je wilt uitvoeren.

Schrijven we tot slot een code die al deze methoden bevat.

object Scala_List_Methods
{

def main(args: Array[String])
{
    // define two lists
    val x = List(1, 40, 10)
    val y = List(20, 25, 30)
    val z = List("DataCamp", "Tutorials", "Are", "The", "Best")

    //Head
    println();
    println("Head of list x, y, z = " + (x.head, y.head, z.head));
    println();

    //Tail
    println("Tail of list x, y, z = " + (x.tail, y.tail, z.tail));
    println();

    //isEmpty
    println("Is list x, y, z empty? = " + (x.isEmpty, y.isEmpty, z.isEmpty));
    println();

    //Concatenate
    println("Concatenating x, y, z lists with the first method = " + (x:::y:::z));
    println("Concatenating x, y, z lists with the second method = " + ((x).:::(y).:::(z)));
    println("Concatenating x, y, z lists with the third method = " + (List.concat(x,y,z)));
    println();

    //Reverse
    println("Reverse of x, y, z is = " + (x.reverse, y.reverse, z.reverse));
    println();

    //Fill
    println("Output of Fill method is = " + (List.fill(5)(z)));
    println();

    //Tabulate
    println("Output of Tabulate method is = " + (List.tabulate(5)(x => x * x * x)));
}
}