Scala for backendutvikling og funksjonell programmering · leksjon

List, Vector, Set, Map

Kjernesamlinger

Leksjon 1 av 413 trinn

List, Vector, Set, Map er en gratis leksjon i Scala for backendutvikling og funksjonell programmering på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Scala for backendutvikling og funksjonell programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Scala for backendutvikling og funksjonell programmering inneholder totalt 4 leksjoner.

Scalas kjernesamlinger

Scala tilbyr flere uforanderlige samlinger i standardbiblioteket. De fire De kommer til å bruke mest, er List, Vector, Set og Map. Hver av dem har ulik ytelse og semantikk.

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: en lenket liste

List er en enkeltlenket liste. Det er O(1) og raskt å legge til først med ::, men tilfeldig tilgang og å legge til sist er O(n). Den egner seg godt til rekursjon og bruk som en stakk.

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: balansert og generell

Vector er en indeksert sekvens med i praksis O(1) for tilgang, oppdatering og innsetting både først og sist. Når De trenger rask tilfeldig tilgang eller en generell sekvens, bør De foretrekke Vector fremfor 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: unike elementer

Et Set lagrer unike elementer uten duplikater og uten garantert rekkefølge. Medlemskapstester med contains er raske.

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

Set-operasjoner

Set støtter matematiske operasjoner: union (|), intersect (&) og 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: nøkkel-verdi-par

En Map knytter nøkler til verdier. Nøklene er unike. Opprett oppføringer med ->-pilen, og slå opp verdier med get (returnerer Option) eller 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))
  }
}

Oppdatere en Map uforanderlig

Uforanderlige map-er returnerer en ny map når De legger til eller fjerner oppføringer; den opprinnelige forblir uendret. Bruk + for å legge til eller overskrive og - for å fjerne.

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

Iterere over en Map

Når De itererer over en Map, får De nøkkel-verdi-tupler. De kan pakke dem ut direkte i en for-comprehension eller med mønstergjenkjenning.

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

Vanlige metoder som deles av alle

Alle disse samlingene deler et stort felles API: size, isEmpty, map, filter, foreach og flere. Lær API-et én gang, så gjelder det overalt.

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

Konvertere mellom samlinger

Konverteringsmetoder som toList, toVector, toSet og toMap gjør det enkelt å bytte type. Konvertering til et Set fjerner duplikater.

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

Velge riktig samling

En rask veiledning:

List — rekursjon, rask innsetting først, behandling av hode/hale
Vector — generell bruk, rask indeksert tilgang
Set — unikhet og medlemskapstester
Map — oppslag basert på nøkler

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

Hurtigsjekk

Hvilken samling fjerner automatisk dupliserte elementer?

Besvar den i den interaktive leksjonen

Oppsummering

De har blitt kjent med Scalas uforanderlige kjernesamlinger:

List — lenket liste, rask innsetting først
Vector — indeksert, godt balansert ytelse
Set — unike elementer med mengdealgebra
Map — nøkkel-verdi-oppslag med get/getOrElse

De deler et omfattende felles API og kan enkelt konverteres til hverandre.

Gratis å komme i gang

Lær deg Scala med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 143

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «List, Vector, Set, Map» gratis?

Ja – hele teksten i «List, Vector, Set, Map» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Scala for backendutvikling og funksjonell programmering-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Scala for backendutvikling og funksjonell programmering inneholder totalt 4 leksjoner.

Hva lærer jeg i «List, Vector, Set, Map»?

Kjernesamlinger Du øver på Scala for backendutvikling og funksjonell programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Scala for backendutvikling og funksjonell programmering?

Ingen tidligere erfaring er nødvendig. Scala for backendutvikling og funksjonell programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «List, Vector, Set, Map»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Scala for backendutvikling og funksjonell programmering-leksjonen?

Ja. Alle Scala for backendutvikling og funksjonell programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Scala for backendutvikling og funksjonell programmering