Scala for Backend Engineering & Functional Programming · Lektion

List, Vector, Set, Map

Zentrale Collections

List, Vector, Set, Map ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Scalas zentrale Collections

Scala bietet in seiner Standardbibliothek mehrere unveränderliche Collections. Die vier, die Sie am häufigsten verwenden werden, sind List, Vector, Set und Map. Jede davon hat andere Leistungsmerkmale und eine andere Semantik.

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: eine verkettete Liste

List ist eine einfach verkettete Liste. Das Voranstellen mit :: hat die Komplexität O(1) und ist schnell, während der wahlfreie Zugriff und das Anhängen O(n) benötigen. Sie eignet sich ideal für Rekursion und die Verwendung 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: ausgewogen und vielseitig

Vector ist eine indizierte Sequenz mit effektiv O(1) für Zugriff, Aktualisierung, Voranstellen und Anhängen. Wenn Sie schnellen wahlfreien Zugriff oder eine vielseitige Sequenz benötigen, bevorzugen Sie Vector gegenüber 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: eindeutige Elemente

Ein Set speichert eindeutige Elemente ohne Duplikate und ohne garantierte Reihenfolge. Mitgliedschaftsprüfungen mit contains sind schnell.

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)
  }
}

Set-Operationen

Sets unterstützen mathematische Operationen: union (|), intersect (&) und 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: Schlüssel-Wert-Paare

Eine Map ordnet Schlüsseln Werte zu. Schlüssel sind eindeutig. Erstellen Sie Einträge mit dem ->-Pfeil und schlagen Sie Werte mit get (liefert Option) oder apply nach.

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))
  }
}

Eine Map unveränderlich aktualisieren

Unveränderliche Maps geben beim Hinzufügen oder Entfernen von Einträgen eine neue Map zurück; das Original bleibt unverändert. Verwenden Sie + zum Hinzufügen oder Überschreiben und - zum Entfernen.

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)
  }
}

Über eine Map iterieren

Beim Iterieren über eine Map erhalten Sie Schlüssel-Wert-Tupel. Sie können sie direkt in einer For-Comprehension oder mit Pattern-Matching entpacken.

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

Gemeinsame Methoden aller Collections

Alle diese Collections verfügen über eine umfangreiche gemeinsame API: size, isEmpty, map, filter, foreach und weitere. Lernen Sie die API einmal, und sie gilt überall.

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))
  }
}

Zwischen Collections konvertieren

Mit Konvertierungsmethoden wie toList, toVector, toSet und toMap können Sie einfach zwischen Typen wechseln. Die Konvertierung in ein Set entfernt Duplikate.

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)
  }
}

Die richtige Collection auswählen

Kurzübersicht:

List — Rekursion, schnelles Voranstellen, Verarbeitung von Kopf und Rest
Vector — vielseitig einsetzbar, schneller indizierter Zugriff
Set — Eindeutigkeit und Mitgliedschaftsprüfungen
Map — schlüsselbasierte Lookups

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)}")
  }
}

Schnelltest

Welche Collection entfernt automatisch doppelte Elemente?

Zusammenfassung

Sie haben Scalas zentrale unveränderliche Collections kennengelernt:

List — verkettete Liste, schnelles Voranstellen
Vector — indiziert, ausgewogene Leistung
Set — eindeutige Elemente mit Mengenoperationen
Map — schlüsselbasierte Lookups mit get/getOrElse

Sie verfügen über eine umfangreiche gemeinsame API und lassen sich problemlos ineinander umwandeln.

Häufig gestellte Fragen

Ist die Lektion „List, Vector, Set, Map“ kostenlos?

Ja — der vollständige Text von „List, Vector, Set, Map“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „List, Vector, Set, Map“?

Zentrale Collections Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „List, Vector, Set, Map“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming