Scala for Backend Engineering & Functional Programming · Lezione

List, Vector, Set, Map

Raccolte fondamentali

List, Vector, Set, Map è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Le collection fondamentali di Scala

Scala offre diverse collection immutabili nella libreria standard. Le quattro che utilizzerà più spesso sono List, Vector, Set e Map. Ognuna ha prestazioni e semantica diverse.

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 concatenata

List è una lista semplicemente concatenata. L'inserimento in testa con :: è O(1) ed è veloce, mentre l'accesso casuale e l'inserimento in coda sono O(n). È ideale per la ricorsione e per l'uso come stack.

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: bilanciato e generico

Vector è una sequenza indicizzata con accesso, aggiornamento, inserimento in testa e inserimento in coda effettivamente O(1). Quando le serve un accesso casuale rapido o una sequenza generica, preferisca Vector a 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: elementi univoci

Un Set contiene elementi distinti, senza duplicati e senza un ordine garantito. I test di appartenenza con contains sono rapidi.

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

Operazioni sui Set

I set supportano operazioni matematiche: union (|), intersect (&) e 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: coppie chiave-valore

Una Map associa chiavi a valori. Le chiavi sono univoche. Crei le associazioni con la freccia -> e cerchi i valori con get (che restituisce Option) o 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))
  }
}

Aggiornare una Map in modo immutabile

Le mappe immutabili restituiscono una nuova mappa quando aggiunge o rimuove associazioni; l'originale non cambia. Usi + per aggiungere o sovrascrivere e - per rimuovere.

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

Iterare su una Map

Iterare su una Map restituisce tuple chiave-valore. Può destrutturarle direttamente in una for-comprehension o con il pattern matching.

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

Metodi comuni a tutte

Tutte queste collection condividono una vasta API comune: size, isEmpty, map, filter, foreach e altro ancora. Impari l'API una volta e potrà applicarla ovunque.

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

Convertire tra collection

I metodi di conversione come toList, toVector, toSet e toMap consentono di cambiare facilmente tipo. La conversione in un Set rimuove i duplicati.

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

Scegliere la collection giusta

Guida rapida:

List — ricorsione, inserimento rapido in testa, elaborazione head/tail
Vector — uso generico, accesso indicizzato rapido
Set — univocità e test di appartenenza
Map — ricerche basate sulle chiavi

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

Verifica rapida

Quale collection rimuove automaticamente gli elementi duplicati?

Riepilogo

Ha conosciuto le collection immutabili fondamentali di Scala:

List — lista concatenata, inserimento rapido in testa
Vector — indicizzato, prestazioni ben bilanciate
Set — elementi univoci con algebra degli insiemi
Map — ricerche chiave-valore con get/getOrElse

Condividono una ricca API comune e si convertono facilmente l'una nell'altra.

Domande Frequenti

La lezione «List, Vector, Set, Map» è gratuita?

Sì — il testo completo di «List, Vector, Set, Map» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «List, Vector, Set, Map»?

Raccolte fondamentali Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «List, Vector, Set, Map»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming