Scala for Backend Engineering & Functional Programming · Lekcja

List, Vector, Set, Map

Podstawowe kolekcje

Lekcja 1 z 413 kroki

List, Vector, Set, Map to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 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.

Podstawowe kolekcje Scali

Scala oferuje w swojej bibliotece standardowej kilka niezmiennych kolekcji. Cztery, których będziesz używać najczęściej, to List, Vector, Set i Map. Każda z nich ma inną charakterystykę wydajnościową i semantykę.

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: lista wiązana

List to jednokierunkowa lista wiązana. Dodawanie elementu na początku za pomocą :: ma złożoność O(1) i jest szybkie, ale swobodny dostęp oraz dodawanie na końcu mają złożoność O(n). Lista ta świetnie nadaje się do rekurencji i zastosowań stosowych.

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: zrównoważona kolekcja ogólnego zastosowania

Vector to sekwencja indeksowana, w której dostęp, aktualizacja, dodawanie na początku i dodawanie na końcu mają efektywnie złożoność O(1). Gdy potrzebujesz szybkiego dostępu losowego lub sekwencji ogólnego zastosowania, wybierz Vector zamiast 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: unikatowe elementy

Set przechowuje unikatowe elementy, bez duplikatów i bez gwarantowanej kolejności. Sprawdzanie przynależności za pomocą contains jest szybkie.

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

Operacje na Set

Zbiory obsługują operacje matematyczne: union (|), intersect (&) i 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: pary klucz-wartość

Map wiąże klucze z wartościami. Klucze są unikatowe. Twórz wpisy za pomocą strzałki ->, a wartości wyszukuj za pomocą get (zwraca Option) lub apply.

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

Niezmienne aktualizowanie Map

Niezmienne mapy zwracają nową mapę po dodaniu lub usunięciu wpisów; oryginalna mapa pozostaje bez zmian. Użyj +, aby dodać wpis lub nadpisać istniejący, oraz -, aby go usunąć.

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

Iterowanie po Map

Iterowanie po Map zwraca krotki klucz-wartość. Można je bezpośrednio rozpakować w for-comprehension lub za pomocą dopasowania wzorców.

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

Wspólne metody wszystkich kolekcji

Wszystkie te kolekcje mają rozbudowane wspólne API, obejmujące między innymi size, isEmpty, map, filter i foreach. Wystarczy nauczyć się API raz, aby stosować je wszędzie.

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

Konwertowanie między kolekcjami

Metody konwersji, takie jak toList, toVector, toSet i toMap, pozwalają łatwo zmieniać typ kolekcji. Konwersja do Set usuwa duplikaty.

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

Wybór odpowiedniej kolekcji

Krótki przewodnik:

List — rekurencja, szybkie dodawanie na początku, przetwarzanie głowy i ogona
Vector — zastosowanie ogólne, szybki dostęp indeksowany
Set — unikatowość i sprawdzanie przynależności
Map — wyszukiwanie na podstawie klucza

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

Szybkie sprawdzenie

Która kolekcja automatycznie usuwa duplikaty elementów?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznałeś(-aś) podstawowe niezmienne kolekcje Scali:

List — lista wiązana, szybkie dodawanie na początku
Vector — kolekcja indeksowana o dobrze zrównoważonej wydajności
Set — unikatowe elementy i algebra zbiorów
Map — wyszukiwanie klucz-wartość za pomocą get/getOrElse

Mają rozbudowane wspólne API i można je łatwo wzajemnie konwertować.

Bezpłatny start

Ucz się Scala dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 143

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „List, Vector, Set, Map” jest bezpłatna?

Tak — pełny tekst „List, Vector, Set, Map” 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 „List, Vector, Set, Map”?

Podstawowe kolekcje Ć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 4.

Ile czasu zajmuje lekcja „List, Vector, Set, Map”?

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