Scala for Backend Engineering & Functional Programming · Lekcja

Grupowanie i sortowanie

groupBy i sortBy

Grupowanie i sortowanie to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Porządkowanie danych

Dane z rzeczywistego świata często trzeba grupować według właściwości lub sortować według klucza. Kolekcje Scali udostępniają do tego deklaratywne metody groupBy, sortBy, sortWith i podobne.

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

sorted: naturalna kolejność

sorted sortuje elementy według ich naturalnej kolejności (liczby rosnąco, a napisy alfabetycznie). Wymaga porządku, który istnieje dla typowych typów.

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

sortBy: sortowanie według klucza

sortBy sortuje według wartości wyprowadzonej z każdego elementu. Należy przekazać funkcję wyodrębniającą klucz sortowania.

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

Sortowanie malejące

Aby sortować malejąco, należy zanegować klucz liczbowy lub użyć sorted(Ordering.Int.reverse). W przypadku kluczy wyprowadzanych z elementów zwięzłym rozwiązaniem jest użycie znaku minus w sortBy.

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: własny komparator

sortWith przyjmuje funkcję zwracającą true, gdy pierwszy argument powinien znaleźć się przed drugim, zapewniając pełną kontrolę nad kolejnością.

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

Sortowanie według wielu kluczy

sortBy może zwracać krotkę, aby jednocześnie sortować według kilku kluczy: najpierw porównywany jest pierwszy element, a następnie drugi, który rozstrzyga remisy.

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: podział na elementy Map

groupBy zwraca obiekt Map, w którym każdy klucz jest wynikiem działania funkcji, a każda wartość to lista elementów mających ten klucz.

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

Grupowanie według obliczonego klucza

Kluczem grupowania może być dowolna wartość: pierwsza litera, długość lub kategoria. Każdy odrębny klucz staje się osobnym wiaderkiem.

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

Transformowanie grup

Po pogrupowaniu często trzeba podsumować każde wiaderko. Do transformowania wartości można użyć view.mapValues (lub map), na przykład w celu zliczenia elementów w każdej grupie.

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 w jednym kroku

groupMapReduce grupuje elementy, mapuje każdy z nich i redukuje wartości w każdej grupie, wykonując wszystko w jednym przejściu. To zwięzły sposób na tworzenie podsumowań, takich jak sumy dla poszczególnych kategorii.

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

Łączenie grupowania i sortowania

Często stosowany wzorzec to: pogrupować dane, podsumować każdą grupę, a następnie posortować podsumowanie. W tym przykładzie zliczamy słowa według pierwszej litery i sortujemy je według liczby wystąpień.

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

Szybkie sprawdzenie

Co zwraca List(1,2,3,4).groupBy(_ % 2 == 0)?

Podsumowanie

Opanował(a) Pan/Pani grupowanie i sortowanie:

sorted — naturalna kolejność
sortBy — sortowanie według wyprowadzonego klucza (krotka umożliwia sortowanie wielokluczowe)
sortWith — własny komparator
groupBy — podział na wiaderka w obiekcie Map
groupMapReduce — grupowanie, mapowanie i redukcja w jednym przejściu

Często zadawane pytania

Czy lekcja „Grupowanie i sortowanie” jest bezpłatna?

Tak — pełny tekst „Grupowanie i sortowanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Grupowanie i sortowanie”?

groupBy i sortBy Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Grupowanie i sortowanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming