Dogłębne poznanie niemutowalnych kolekcji
Poznaj podstawowe niemutowalne kolekcje, takie jak List, Map i Set, oraz naucz się efektywnie z nich korzystać.
Dogłębne poznanie niemutowalnych kolekcji to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 z 3. 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 3 lekcji w sumie.
Niezmienne kolekcje: przegląd
Witamy w świecie niezmiennych kolekcji! W Scali są one podstawą tworzenia solidnego, współbieżnego i przewidywalnego kodu, szczególnie w programowaniu funkcyjnym.
Przyjrzymy się podstawowym typom, takim jak List, Map i Set, koncentrując się na ich wydajnym i bezpiecznym użyciu.
Dlaczego niezmienność ma znaczenie
Niezmienność oznacza, że po utworzeniu kolekcji nie można jej zmienić. Każda operacja, która wygląda na „modyfikację”, w rzeczywistości zwraca nową kolekcję.
- Przewidywalność: Kod łatwiej analizować.
- Bezpieczeństwo wątkowe: Nie trzeba używać blokad, ponieważ dane nigdy się nie zmieniają.
- Brak efektów ubocznych: Operacje nie zmienią niespodziewanie danych w innym miejscu.
Listy w Scali: uporządkowane sekwencje
List w Scali to niezmienna, uporządkowana sekwencja elementów tego samego typu. Doskonale nadaje się do danych sekwencyjnych, w przypadku których kolejność ma znaczenie.
Listę można utworzyć, po prostu wyliczając jej elementy.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(1, 2, 3, 4, 5)
val fruits = List("apple", "banana", "cherry")
println(s"Numbers list: $numbers")
println(s"Fruits list: $fruits")
}
}Operacje na listach: head, tail, cons
Listy udostępniają typowe operacje, takie jak pobieranie head (pierwszego elementu) i tail (pozostałej części listy). Operator :: (cons) służy do dodawania elementu na początku i tworzy nową listę.
object Main {
def main(args: Array[String]): Unit = {
val numbers = List(10, 20, 30)
println(s"Original list: $numbers")
println(s"Head of list: ${numbers.head}") // 10
println(s"Tail of list: ${numbers.tail}") // List(20, 30)
val newList = 5 :: numbers // Prepend 5
println(s"List with 5 prepended: $newList")
}
}Mapy w Scali: skojarzenia klucz-wartość
Map to niezmienna kolekcja przechowująca pary klucz-wartość. Każdy klucz jest unikatowy i wskazuje jedną wartość. Mapy doskonale nadają się do wyszukiwania wartości na podstawie konkretnego klucza.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25, "Charlie" -> 35)
val codes = Map(1 -> "One", 2 -> "Two")
println(s"Ages map: $ages")
println(s"Codes map: $codes")
}
}Operacje na mapach: dostęp i aktualizacja
Do wartości w mapie można uzyskać dostęp za pomocą jej klucza. Aby „zaktualizować” lub dodać parę klucz-wartość, należy utworzyć nową mapę ze zmianami, pozostawiając oryginalną mapę bez zmian.
object Main {
def main(args: Array[String]): Unit = {
val ages = Map("Alice" -> 30, "Bob" -> 25)
println(s"Original ages: $ages")
println(s"Bob's age: ${ages("Bob")}")
val updatedAges = ages + ("Charlie" -> 35) // Add new pair
println(s"Ages after adding Charlie: $updatedAges")
val changedAges = updatedAges + ("Alice" -> 31) // Update Alice's age
println(s"Ages after updating Alice: $changedAges")
}
}Zbiory w Scali: unikatowe elementy
Set to niezmienna kolekcja unikatowych elementów. W przeciwieństwie do list kolejność elementów w zbiorze nie jest gwarantowana, a duplikaty są automatycznie ignorowane.
Zbiory doskonale nadają się do sprawdzania przynależności elementów lub zapewniania ich unikatowości.
object Main {
def main(args: Array[String]): Unit = {
val numbers = Set(1, 2, 2, 3, 4, 3, 5)
val letters = Set('a', 'b', 'a')
println(s"Unique numbers: $numbers")
println(s"Unique letters: $letters")
}
}Operacje na zbiorach: dodawanie, usuwanie, suma
Podobnie jak w przypadku list i map, operacje na zbiorach, takie jak dodawanie lub usuwanie elementów, również zwracają nowy zbiór. Można także wykonywać operacje teorii mnogości, takie jak union (łączenie zbiorów).
object Main {
def main(args: Array[String]): Unit = {
val setA = Set(1, 2, 3)
val setB = Set(3, 4, 5)
println(s"Set A: $setA")
println(s"Set B: $setB")
val addedSet = setA + 4 // Add element
println(s"Set A + 4: $addedSet")
val removedSet = setA - 2 // Remove element
println(s"Set A - 2: $removedSet")
val unionSet = setA union setB // Combine sets
println(s"Set A union Set B: $unionSet")
}
}Niezmienność: oryginał pozostaje bez zmian
Należy pamiętać, że wszystkie operacje „modyfikujące” niezmienne kolekcje w Scali zwracają nową kolekcję. Oryginalna kolekcja nigdy nie jest zmieniana.
To zachowanie jest jednym z fundamentów programowania funkcyjnego w Scali.
object Main {
def main(args: Array[String]): Unit = {
val originalList = List(10, 20, 30)
println(s"Original List: $originalList")
val doubledList = originalList.map(_ * 2) // map returns a NEW list
println(s"List after map: $doubledList")
println(s"Original list is still: $originalList") // Unchanged!
}
}Sprawdź swoją wiedzę
Rozważmy następujący fragment kodu Scali:
val mySet = Set(1, 2, 3)
val newSet = mySet + 3 + 4
val finalSet = newSet - 2Jaka będzie wartość mySet po wykonaniu tych operacji?
Podsumowanie: niezmienne kolekcje
Dokładnie poznali Państwo podstawowe niezmienne kolekcje Scali:
- Listy: Uporządkowane sekwencje, dobre do danych sekwencyjnych.
- Mapy: Pary klucz-wartość, wydajne podczas wyszukiwania.
- Zbiory: Unikatowe elementy, świetne do sprawdzania przynależności.
Najważniejszy wniosek to niezmienność: operacje zawsze zwracają nowe kolekcje, zapewniając przewidywalność i bezpieczeństwo.
Często zadawane pytania
Czy lekcja „Dogłębne poznanie niemutowalnych kolekcji” jest bezpłatna?
Tak — pełny tekst „Dogłębne poznanie niemutowalnych kolekcji” 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 3 lekcji w sumie.
Co nauczysz się w „Dogłębne poznanie niemutowalnych kolekcji”?
Poznaj podstawowe niemutowalne kolekcje, takie jak List, Map i Set, oraz naucz się efektywnie z nich korzystać. Ć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 1 z 3.
Ile czasu zajmuje lekcja „Dogłębne poznanie niemutowalnych kolekcji”?
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
- Dogłębne poznanie niemutowalnych kolekcji
- Operacje funkcyjne na kolekcjach
- Option, Try i Either do obsługi błędów