Przekształcenia
map, filter, flatMap
Przekształcenia to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 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.
Przekształcanie kolekcji
Kolekcje Scali są domyślnie niezmienne. Zamiast je modyfikować, przekształcasz je w nowe kolekcje za pomocą metod takich jak map, filter i flatMap.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4)
val doubled = nums.map(_ * 2)
println(nums)
println(doubled)
}
}map: przekształcanie każdego elementu
map stosuje funkcję do każdego elementu i zwraca nową kolekcję o tym samym rozmiarze. Typ elementów może się zmienić.
object Main {
def main(args: Array[String]): Unit = {
val words = List("scala", "rocks")
val lengths = words.map(_.length)
println(lengths)
}
}Skrócona składnia z podkreśleniem
Podkreślenie _ jest skrótem dla pojedynczego parametru funkcji. _ * 2 oznacza x => x * 2. Dzięki niemu proste przekształcenia są bardziej zwięzłe.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(10, 20, 30)
println(nums.map(_ + 1))
println(nums.map(x => x + 1))
}
}filter: zachowywanie pasujących elementów
filter zachowuje tylko te elementy, dla których predykat zwraca true. Wynik może być mniejszy od oryginału.
object Main {
def main(args: Array[String]): Unit = {
val nums = (1 to 10).toList
val evens = nums.filter(_ % 2 == 0)
println(evens)
}
}filterNot: odwrotność
filterNot zachowuje elementy, dla których predykat zwraca false. Jest dopełnieniem filter.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3, 4, 5)
println(nums.filterNot(_ % 2 == 0))
}
}flatMap: mapowanie, a następnie spłaszczanie
flatMap stosuje do każdego elementu funkcję zwracającą kolekcję, a następnie spłaszcza wyniki do jednej kolekcji.
object Main {
def main(args: Array[String]): Unit = {
val words = List("ab", "cd")
val chars = words.flatMap(_.toList)
println(chars)
}
}map a flatMap
Jeśli funkcja zwraca kolekcję, map tworzy zagnieżdżone kolekcje, a flatMap — jedną płaską kolekcję. Wybierz metodę zależnie od oczekiwanego kształtu wyniku.
object Main {
def main(args: Array[String]): Unit = {
val nums = List(1, 2, 3)
println(nums.map(n => List(n, n)))
println(nums.flatMap(n => List(n, n)))
}
}flatMap z Option
flatMap zastosowane do listy wartości Option usuwa wartości None i rozpakowuje wartości Some. To wygodny sposób na jednoczesne filtrowanie i przekształcanie.
object Main {
def main(args: Array[String]): Unit = {
val raw = List("1", "x", "3", "y")
val parsed = raw.flatMap(_.toIntOption)
println(parsed)
}
}collect: jednoczesne filtrowanie i mapowanie
collect przyjmuje funkcję częściową: zachowuje i przekształca tylko te elementy, dla których funkcja jest określona, łącząc filter i map w jednym przebiegu.
object Main {
def main(args: Array[String]): Unit = {
val mixed: List[Any] = List(1, "two", 3, "four", 5)
val ints = mixed.collect { case i: Int => i * 10 }
println(ints)
}
}Łączenie przekształceń
Ponieważ każda metoda zwraca nową kolekcję, można łączyć metody w czytelny potok. Każdy krok przekształca wynik poprzedniego.
object Main {
def main(args: Array[String]): Unit = {
val result = List(1, 2, 3, 4)
.map(_ + 1)
.filter(_ % 2 == 0)
println(result)
}
}Przejrzysty potok
Oto uporządkowany potok przekształceń: odfiltruj liczby parzyste, podnieś je do kwadratu, a następnie pozostaw duże wartości. Potoki przypominają opis przepływu danych.
object Main {
def main(args: Array[String]): Unit = {
val result = (1 to 10).toList
.filter(_ % 2 == 0)
.map(x => x * x)
.filter(_ > 10)
println(result)
}
}Szybkie sprawdzenie
Co zwraca List("ab", "cd").flatMap(_.toList)?
Podsumowanie
Opanował(a) Pan/Pani podstawowe transformacje:
map— transformuje każdy element, zachowując rozmiarfilter/filterNot— zachowuje elementy spełniające predykat lub je odrzucaflatMap— mapuje, a następnie spłaszcza zagnieżdżone wynikicollect— filtruje i mapuje za pomocą funkcji częściowej- Łącz je w czytelne, niemutowalne potoki
Często zadawane pytania
Czy lekcja „Przekształcenia” jest bezpłatna?
Tak — pełny tekst „Przekształcenia” 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 „Przekształcenia”?
map, filter, flatMap Ć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 2 z 4.
Ile czasu zajmuje lekcja „Przekształcenia”?
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.