Scala for Backend Engineering & Functional Programming · Lektion

Gruppieren und Sortieren

groupBy und sortBy

Gruppieren und Sortieren ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Daten organisieren

Daten aus der Praxis müssen häufig nach einer Eigenschaft gruppiert oder nach einem Schlüssel sortiert werden. Scala-Collections bieten dafür deklarative Methoden wie groupBy, sortBy und sortWith.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1, 9, 2)
    println(nums.sorted)
  }
}

sorted: natürliche Reihenfolge

sorted sortiert Elemente in ihrer natürlichen Reihenfolge (aufsteigend bei Zahlen, alphabetisch bei Strings). Dafür wird eine Ordnung benötigt, die für gängige Typen vorhanden ist.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 2).sorted)
    println(List("pear", "apple", "fig").sorted)
  }
}

sortBy: nach einem Schlüssel sortieren

sortBy sortiert nach einem aus jedem Element abgeleiteten Wert. Übergeben Sie eine Funktion, die den Sortierschlüssel extrahiert.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("banana", "fig", "apple")
    val byLength = words.sortBy(_.length)
    println(byLength)
  }
}

Absteigend sortieren

Um absteigend zu sortieren, negieren Sie einen numerischen Schlüssel oder verwenden Sie sorted(Ordering.Int.reverse). Bei abgeleiteten Schlüsseln ist sortBy mit einem Minuszeichen besonders kompakt.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    println(nums.sortBy(-_))
    println(nums.sorted(Ordering.Int.reverse))
  }
}

sortWith: eigener Vergleich

sortWith übernimmt eine Funktion, die true zurückgibt, wenn das erste Argument vor dem zweiten stehen soll. Dadurch erhalten Sie vollständige Kontrolle über die Reihenfolge.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    val descending = nums.sortWith((a, b) => a > b)
    println(descending)
  }
}

Nach mehreren Schlüsseln sortieren

sortBy kann ein Tupel zurückgeben, um gleichzeitig nach mehreren Schlüsseln zu sortieren: Zuerst wird das erste Element verglichen, dann das zweite, um Gleichstände aufzulösen.

object Main {
  def main(args: Array[String]): Unit = {
    val people = List(("Ann", 30), ("Bob", 25), ("Ann", 22))
    val sorted = people.sortBy { case (name, age) => (name, age) }
    println(sorted)
  }
}

groupBy: in eine Map aufteilen

groupBy gibt eine Map zurück, in der jeder Schlüssel das Ergebnis Ihrer Funktion und jeder Wert die Liste der Elemente mit diesem Schlüssel ist.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    val byParity = nums.groupBy(_ % 2 == 0)
    println(byParity)
  }
}

Nach einem berechneten Schlüssel gruppieren

Der Gruppierungsschlüssel kann beliebig sein: ein Anfangsbuchstabe, eine Länge oder eine Kategorie. Jeder unterschiedliche Schlüssel wird zu einem eigenen Bucket.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry")
    val byFirstLetter = words.groupBy(_.head)
    byFirstLetter.foreach { case (letter, ws) => println(s"$letter -> $ws") }
  }
}

Gruppen transformieren

Nach dem Gruppieren möchten Sie häufig jeden Bucket zusammenfassen. Verwenden Sie view.mapValues (oder map), um die Werte zu transformieren, zum Beispiel um die Elemente pro Gruppe zu zählen.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("cat", "car", "dog", "deer", "cow")
    val counts = words.groupBy(_.head).view.mapValues(_.size).toMap
    println(counts)
  }
}

groupMapReduce in einem Schritt

groupMapReduce gruppiert, bildet jedes Element ab und reduziert die Werte jeder Gruppe in einem einzigen Durchlauf. Damit lassen sich Zusammenfassungen wie Summen pro Kategorie kompakt erstellen.

object Main {
  def main(args: Array[String]): Unit = {
    val sales = List(("books", 10), ("toys", 5), ("books", 7), ("toys", 3))
    val totals = sales.groupMapReduce(_._1)(_._2)(_ + _)
    println(totals)
  }
}

Gruppieren und Sortieren kombinieren

Ein häufig verwendetes Muster: Daten gruppieren, jede Gruppe zusammenfassen und anschließend die Zusammenfassung sortieren. Hier zählen wir Wörter nach ihrem Anfangsbuchstaben und sortieren nach der Anzahl.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry", "apricot")
    val ranked = words
      .groupBy(_.head)
      .view.mapValues(_.size).toList
      .sortBy(-_._2)
    println(ranked)
  }
}

Kurze Überprüfung

Was gibt List(1,2,3,4).groupBy(_ % 2 == 0) zurück?

Zusammenfassung

Sie haben Gruppieren und Sortieren kennengelernt:

sorted — natürliche Reihenfolge
sortBy — nach einem abgeleiteten Schlüssel sortieren (Tupel für mehrere Schlüssel)
sortWith — eigener Vergleich
groupBy — in eine Map aus Buckets aufteilen
groupMapReduce — in einem Durchlauf gruppieren, abbilden und reduzieren

Häufig gestellte Fragen

Ist die Lektion „Gruppieren und Sortieren“ kostenlos?

Ja — der vollständige Text von „Gruppieren und Sortieren“ 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 „Gruppieren und Sortieren“?

groupBy und sortBy 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 4 von 4.

Wie lange dauert die Lektion „Gruppieren und Sortieren“?

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