Liste in Scala

Potrebbero interessarti anche i seguenti tutorial:

• Guida per principianti a Scala
• IF ELSE in Scala
• Operatori in Scala

Introduzione

Una struttura di lista semplicemente concatenata, che implementa una lista con 3 elementi interi (Fonte: Wikipedia - List (abstract data type)).

In generale, una lista è una sequenza di tipi di dato astratti che rappresenta un numero fissato di valori. I valori possono essere manipolati a livello di programma e possono anche comparire più volte in una lista. Un'istanza di lista è mostrata nella figura sopra come una lista semplicemente concatenata composta da tre valori interi. La lista è considerata anche una struttura dati, e un esempio di lista come struttura dati sono le liste concatenate.

Molti linguaggi di programmazione supportano le liste e un esempio in cui le liste sono ampiamente usate è Python. Una lista può spesso essere costruita scrivendo gli elementi in sequenza, separati da virgole, punto e virgola o spazi, all'interno di una coppia di delimitatori come parentesi tonde (), quadre [], graffe {} o angolari <>. Alcuni linguaggi come Python possono consentire di indicizzare o effettuare slicing sui tipi lista come sugli array; in tal caso il tipo di dato è più accuratamente descritto come un array (Fonte: Wikipedia - List (abstract data type)).

Nello specifico di Scala, una lista è una collection che contiene dati immutabili, il che significa che una volta creata non può essere modificata. In Scala, la lista rappresenta una linked list.

In una lista Scala, ogni elemento non deve necessariamente essere dello stesso tipo di dato. L'implementazione delle liste in Scala usa uno stato mutabile internamente durante la fase di costruzione. In Scala, la lista è definita nel package scala.collection.immutable e quindi è immutabile. Infine, una Scala List offre vari metodi come add, prepend, max, min, ecc.

Sintassi per definire una Scala List

val variable_name: List[type] = List(item1, item2, item3) oppure val variable_name = List(item1, item2, item3) Una lista in Scala è per lo più simile a un array Scala. Tuttavia, la Scala List è immutabile e rappresenta una struttura dati di tipo linked list. L'array Scala, invece, è piatto e mutabile.

Comprendiamo rapidamente la differenza con un esempio.

Scala List vs. Scala Array

Definiamo prima un array in Scala.

Poi modificherai un valore all'indice 1, dato che gli array Scala sono indicizzati da zero, per vedere se riesci ad aggiornarlo.

Come puoi vedere dallo snippet di codice sopra, l'array Scala ti ha permesso di modificare il valore all'indice 1.

Ora definirai una Scala List e proverai a imitare quanto fatto sopra.

Dal precedente esempio puoi concludere che, essendo le Scala List immutabili, l'aggiornamento del valore ha generato un errore.

Metodi di Scala List

• head: Questo metodo restituisce il primo elemento della lista Scala.

• tail: Questo metodo restituisce tutti gli elementi tranne il primo.

• isEmpty: Questo metodo verifica se la lista è vuota; in tal caso restituisce True, altrimenti False.

• fill(): Questo metodo crea una lista uniforme composta da zero o più copie dell'elemento specificato.

• reverse: Questo metodo inverte gli elementi della lista.

• $:::$ o $.:::$ o .concat(): Concatena due o più liste.

• tabulate(): Questo metodo può tabulare una lista. È simile nello spirito al metodo fill(), ma a differenza di fill() accetta due argomenti. Il primo argomento indica le dimensioni della lista da creare, mentre il secondo descrive gli elementi della lista, calcolati da una funzione.

Non preoccuparti se alcuni dei metodi sopra non ti sono chiarissimi: li implementerai in Scala con un esempio, ma prima vediamo come definire le Scala List.

Creerai Scala List con tipi di dato string, integer (sia 1D che 2D). Imparerai anche a creare una lista composta sia da stringhe sia da interi.

Lista di interi 1-D

Lista 1-D con interi e stringhe

Lista di stringhe 1-D

Lista 2-D

Operazioni aritmetiche sulle liste

In questo esempio userai le liste invece di definire solo variabili. A differenza di una variabile, una List può contenere un numero n di valori; eseguirai operazioni aritmetiche sulle due liste invece che su due variabili.

Vediamo rapidamente come farlo.

Per applicare le operazioni aritmetiche userai la funzione zipped.map, seguita dalle liste x e y. Quindi specificherai nel metodo zipped.map l'operazione che vuoi eseguire come argomento.

Infine, scriviamo un codice che includa tutti questi metodi.

object Scala_List_Methods
{

def main(args: Array[String])
{
    // define two lists
    val x = List(1, 40, 10)
    val y = List(20, 25, 30)
    val z = List("DataCamp", "Tutorials", "Are", "The", "Best")

    //Head
    println();
    println("Head of list x, y, z = " + (x.head, y.head, z.head));
    println();

    //Tail
    println("Tail of list x, y, z = " + (x.tail, y.tail, z.tail));
    println();

    //isEmpty
    println("Is list x, y, z empty? = " + (x.isEmpty, y.isEmpty, z.isEmpty));
    println();

    //Concatenate
    println("Concatenating x, y, z lists with the first method = " + (x:::y:::z));
    println("Concatenating x, y, z lists with the second method = " + ((x).:::(y).:::(z)));
    println("Concatenating x, y, z lists with the third method = " + (List.concat(x,y,z)));
    println();

    //Reverse
    println("Reverse of x, y, z is = " + (x.reverse, y.reverse, z.reverse));
    println();

    //Fill
    println("Output of Fill method is = " + (List.fill(5)(z)));
    println();

    //Tabulate
    println("Output of Tabulate method is = " + (List.tabulate(5)(x => x * x * x)));
}
}

Conclusione

Congratulazioni per aver completato questo tutorial su Scala.

Per qualsiasi domanda relativa a questo tutorial, sentiti libero di scrivere nella sezione commenti qui sotto.