Listen in Scala

Diese Tutorials könnten dich ebenfalls interessieren:

• Beginners Guide to Scala
• IF ELSE in Scala
• Operators in Scala

Einführung

Eine einfach verkettete Listenstruktur mit drei Integer-Elementen (Quelle: Wikipedia - List (abstract data type)).

Eine Liste ist allgemein eine Folge abstrakter Datentypen, die eine feste Anzahl von Werten repräsentiert. Diese Werte können programmatisch verarbeitet werden und dürfen auch mehrfach in der Liste vorkommen. Ein Beispiel für eine Instanz einer Liste siehst du oben als einfach verkettete Liste mit drei Ganzzahlen. Listen gelten ebenfalls als Datenstruktur; ein typisches Beispiel dafür sind verkettete Listen.

Viele Programmiersprachen unterstützen Listen, und ein prominentes Beispiel, in dem Listen intensiv genutzt werden, ist Python. Eine Liste lässt sich oft erstellen, indem man Elemente in einer Reihenfolge innerhalb von Trennzeichen wie Klammern (), eckigen Klammern [], geschweiften Klammern {} oder spitzen Klammern <> notiert und mit Kommas, Semikolons oder Leerzeichen trennt. Manche Sprachen wie Python erlauben es, Listentypen wie Arrays zu indizieren oder zu slicen; dann beschreibt man den Datentyp treffender als Array (Quelle: Wikipedia - List (abstract data type)).

Speziell in Scala ist eine List eine Sammlung mit unveränderlichen Daten. Das bedeutet: Sobald die Liste erstellt ist, lässt sie sich nicht mehr ändern. In Scala entspricht die List einer verketteten Liste.

In einer Scala-Liste müssen die Elemente nicht alle vom selben Datentyp sein. Die Implementierung von Scala-Listen nutzt während der Erstellung intern einen veränderlichen Zustand. In Scala ist die Liste im Paket scala.collection.immutable definiert und daher unveränderlich. Eine Scala-List bietet zahlreiche Methoden wie add, prepend, max, min usw.

Syntax zum Definieren einer Scala-List

val variable_name: List[type] = List(item1, item2, item3) oder val variable_name = List(item1, item2, item3) Eine Liste in Scala ähnelt stark einem Scala-Array. Allerdings ist die Scala-List unveränderlich und repräsentiert eine verkettete Listenstruktur. Ein Scala-Array hingegen ist flach und veränderlich.

Schauen wir uns den Unterschied kurz an einem Beispiel an.

Scala List vs. Scala Array

Definieren wir zuerst ein Array in Scala.

Anschließend änderst du einen Wert am 1. Index (Scala-Arrays sind nullbasiert) und prüfst, ob sich der Wert aktualisieren lässt.

Wie du im obigen Codeschnipsel siehst, erlaubt dir das Scala-Array die Änderung am 1. Index.

Jetzt definierst du eine Scala List und versuchst dasselbe.

Aus dem Beispiel erkennst du: Weil Scala-Listen unveränderlich sind, führt das Aktualisieren eines Werts zu einem Fehler.

Scala-List-Methoden

• head: Gibt das erste Element der Scala-Liste zurück.

• tail: Gibt alle Elemente außer dem ersten zurück.

• isEmpty: Prüft, ob die Liste leer ist, und liefert entsprechend True oder False.

• fill(): Erstellt eine uniforme Liste mit null oder mehr Kopien des angegebenen Elements.

• reverse: Kehrt die Reihenfolge der Elemente in der Liste um.

• $:::$ oder $.:::$ oder .concat(): Verknüpft zwei oder mehr Listen miteinander.

• tabulate(): Erzeugt eine Liste per Tabellierung. Ähnlich zur Methode fill(), allerdings nimmt tabulate() zwei Argumente: Das erste gibt die Dimension der zu erstellenden Liste an, das zweite beschreibt die Elemente, die über eine Funktion berechnet werden.

Keine Sorge, falls dir einige der Methoden noch nicht vertraut sind. Du setzt sie gleich in Scala anhand von Beispielen um. Zuvor lernst du, wie man Scala-Listen definiert.

Du erstellst Scala-Listen mit den Datentypen Strings, Integer (1D & 2D). Außerdem lernst du, eine Liste zu erzeugen, die sowohl Strings als auch Integer enthält.

1D-Integer-Liste

1D-Liste mit Integer und String

1D-String-Liste

2D-Liste

Arithmetische Operationen auf Listen

In diesem Beispiel verwendest du Listen anstelle einzelner Variablen. Anders als eine Variable kann eine List n Werte halten; du führst die arithmetischen Operationen daher auf zwei Listen statt auf zwei Variablen aus.

Schauen wir uns kurz an, wie das geht.

Für die arithmetischen Operationen nutzt du die Funktion zipped.map in Kombination mit den Listen x und y. In der Methode zipped.map gibst du als Argument die jeweilige Operation an.

Zum Abschluss schreiben wir einen Code, der all diese Methoden enthält.

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)));
}
}
Bereitgestellt von

Fazit

Glückwunsch zum Abschluss dieses Scala-Tutorials.

Stelle gern deine Fragen zu diesem Tutorial unten in den Kommentaren.