Scala for Backend Engineering & Functional Programming · Lezione

Raggruppamento e ordinamento

groupBy e sortBy

Lezione 4 di 413 passaggi

Raggruppamento e ordinamento è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 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.

Organizzare i dati

I dati del mondo reale spesso devono essere raggruppati in base a una proprietà o ordinati in base a una chiave. Le collezioni Scala offrono groupBy, sortBy, sortWith e metodi simili per farlo in modo dichiarativo.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1, 9, 2)
    println(nums.sorted)
  }
}

sorted: ordine naturale

sorted ordina gli elementi secondo il loro ordine naturale (crescente per i numeri, alfabetico per le stringhe). Richiede un ordinamento, disponibile per i tipi più comuni.

object Main {
  def main(args: Array[String]): Unit = {
    println(List(3, 1, 2).sorted)
    println(List("pear", "apple", "fig").sorted)
  }
}

sortBy: ordinare in base a una chiave

sortBy ordina in base a un valore derivato da ciascun elemento. È necessario fornire una funzione che estragga la chiave di ordinamento.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("banana", "fig", "apple")
    val byLength = words.sortBy(_.length)
    println(byLength)
  }
}

Ordinare in ordine decrescente

Per ordinare in modo decrescente, neghi una chiave numerica oppure usi sorted(Ordering.Int.reverse). Per le chiavi derivate, usare sortBy con un segno meno è una soluzione concisa.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    println(nums.sortBy(-_))
    println(nums.sorted(Ordering.Int.reverse))
  }
}

sortWith: comparatore personalizzato

sortWith accetta una funzione che restituisce true quando il primo argomento deve comparire prima del secondo, offrendo il pieno controllo sull'ordinamento.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(5, 3, 8, 1)
    val descending = nums.sortWith((a, b) => a > b)
    println(descending)
  }
}

Ordinare in base a più chiavi

sortBy può restituire una tupla per ordinare in base a più chiavi contemporaneamente: confronta il primo elemento, poi il secondo per risolvere i casi di parità.

object Main {
  def main(args: Array[String]): Unit = {
    val people = List(("Ann", 30), ("Bob", 25), ("Ann", 22))
    val sorted = people.sortBy { case (name, age) => (name, age) }
    println(sorted)
  }
}

groupBy: suddividere in una Map

groupBy restituisce una Map in cui ogni chiave è il risultato della funzione e ogni valore è la lista di elementi che condividono quella chiave.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    val byParity = nums.groupBy(_ % 2 == 0)
    println(byParity)
  }
}

Raggruppare in base a una chiave calcolata

La chiave di raggruppamento può essere qualsiasi cosa: una prima lettera, una lunghezza, una categoria. Ogni chiave distinta diventa un gruppo.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry")
    val byFirstLetter = words.groupBy(_.head)
    byFirstLetter.foreach { case (letter, ws) => println(s"$letter -> $ws") }
  }
}

Trasformare i gruppi

Dopo il raggruppamento, spesso è utile riepilogare ogni gruppo. Usi view.mapValues (oppure map) per trasformare i valori, ad esempio contando gli elementi di ogni gruppo.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("cat", "car", "dog", "deer", "cow")
    val counts = words.groupBy(_.head).view.mapValues(_.size).toMap
    println(counts)
  }
}

groupMapReduce in un unico passaggio

groupMapReduce raggruppa, esegue il mapping di ogni elemento e riduce i valori di ciascun gruppo, tutto in un'unica passata. È un modo conciso per creare riepiloghi come le somme per categoria.

object Main {
  def main(args: Array[String]): Unit = {
    val sales = List(("books", 10), ("toys", 5), ("books", 7), ("toys", 3))
    val totals = sales.groupMapReduce(_._1)(_._2)(_ + _)
    println(totals)
  }
}

Combinare raggruppamento e ordinamento

Un modello frequente consiste nel raggruppare i dati, riepilogare ogni gruppo e poi ordinare il riepilogo. Qui contiamo le parole per prima lettera e ordiniamo in base al conteggio.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "avocado", "banana", "cherry", "cranberry", "apricot")
    val ranked = words
      .groupBy(_.head)
      .view.mapValues(_.size).toList
      .sortBy(-_._2)
    println(ranked)
  }
}

Verifica rapida

Che cosa restituisce List(1,2,3,4).groupBy(_ % 2 == 0)?

Rispondi nella lezione interattiva

Riepilogo

Ha appreso il raggruppamento e l'ordinamento:

sorted — ordine naturale
sortBy — ordina in base a una chiave derivata (una tupla per più chiavi)
sortWith — comparatore personalizzato
groupBy — suddivide in una Map di gruppi
groupMapReduce — raggruppa, esegue il mapping e riduce in un'unica passata

Gratis per iniziare

Impara Scala con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 143

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Raggruppamento e ordinamento» è gratuita?

Sì — il testo completo di «Raggruppamento e ordinamento» è 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 «Raggruppamento e ordinamento»?

groupBy e sortBy 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 4 di 4.

Quanto tempo richiede la lezione «Raggruppamento e ordinamento»?

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