Collezioni Scala - Guida rapida

Scala dispone di un ricco set di raccolte librarie. Le collezioni sono contenitori di cose. Questi contenitori possono essere sequenziati, insiemi lineari di elementi come List, Tuple, Option, Map, ecc. Le raccolte possono avere un numero arbitrario di elementi o essere limitate a zero o un elemento (ad esempio, Option).

Le collezioni possono essere strict o lazy. Le raccolte pigre hanno elementi che potrebbero non consumare memoria fino a quando non vi si accede, comeRanges. Inoltre, le raccolte possono esseremutable (il contenuto del riferimento può cambiare) o immutable(la cosa a cui si riferisce un riferimento non viene mai modificata). Tieni presente che le raccolte immutabili possono contenere elementi modificabili.

Per alcuni problemi, le raccolte modificabili funzionano meglio e per altri, le raccolte immutabili funzionano meglio. In caso di dubbio, è meglio iniziare con una raccolta immutabile e modificarla in un secondo momento se sono necessarie quelle modificabili.

Questo capitolo fa luce sui tipi di raccolta più comunemente usati e sulle operazioni utilizzate più di frequente su tali raccolte.

Suor n	Collezioni con descrizione
1	Scala Lists Scala's List [T] è una lista concatenata di tipo T.
2	Scala Sets Un set è una raccolta di elementi diversi a coppie dello stesso tipo.
3	Scala Maps Una mappa è una raccolta di coppie chiave / valore. Qualsiasi valore può essere recuperato in base alla sua chiave.
4	Scala Tuples A differenza di un array o di un elenco, una tupla può contenere oggetti con tipi diversi.
5	Scala Options L'opzione [T] fornisce un contenitore per zero o un elemento di un dato tipo.
6	Scala Iterators Un iteratore non è una raccolta, ma piuttosto un modo per accedere agli elementi di una raccolta uno per uno.

Scala può essere installato su qualsiasi sistema UNIX o basato su Windows. Prima di iniziare l'installazione di Scala sulla tua macchina, devi avere Java 1.8 o superiore installato sul tuo computer.

Seguire i passaggi indicati di seguito per installare Scala.

Passaggio 1: verifica l'installazione di Java

Prima di tutto, devi avere Java Software Development Kit (SDK) installato sul tuo sistema. Per verificarlo, esegui uno dei seguenti due comandi a seconda della piattaforma su cui stai lavorando.

Se l'installazione di Java è stata eseguita correttamente, verranno visualizzate la versione corrente e le specifiche dell'installazione di Java. Un output di esempio è fornito nella tabella seguente.

piattaforma	Comando	Output di esempio
finestre	Apri la Console di comando e digita - \>java -version	Versione Java "1.8.0_31" Java (TM) SE Run Time Ambiente (build 1.8.0_31-b31) Server Java Hotspot (TM) a 64 bit VM (build 25.31-b07, modalità mista)
Linux	Apri il terminale di comando e digita - $java -version	Versione Java "1.8.0_31" Aprire JDK Runtime Environment (rhel-2.8.10.4.el6_4-x86_64) Apri la VM server JDK a 64 bit (build 25.31-b07, modalità mista)

Si presume che i lettori di questo tutorial abbiano Java SDK versione 1.8.0_31 installato sul proprio sistema.

Se non disponi di Java SDK, scarica la versione corrente da https://www.oracle.com/technetwork/java/javase/downloads/index.html e installalo.

Passaggio 2: imposta il tuo ambiente Java

Impostare la variabile di ambiente JAVA_HOME in modo che punti alla posizione della directory di base in cui Java è installato sulla macchina. Per esempio,

Suor n	Piattaforma e descrizione
1	Windows Impostare JAVA_HOME su C: \ ProgramFiles \ java \ jdk1.8.0_31
2	Linux Esporta JAVA_HOME = / usr / local / java-current

Aggiungi il percorso completo della posizione del compilatore Java al percorso di sistema.

Suor n	Piattaforma e descrizione
1	Windows Aggiungi la stringa "C: \ Programmi \ Java \ jdk1.8.0_31 \ bin" alla fine della variabile di sistema PATH.
2	Linux Esporta PATH = $ PATH: $ JAVA_HOME / bin /

Esegui il comando java -version dal prompt dei comandi come spiegato sopra.

Passaggio 3: installa Scala

Puoi scaricare Scala da www.scala-lang.org/downloads . Al momento della stesura di questo tutorial, ho scaricato 'scala-2.13.1-installer.jar'. Assicurati di disporre dei privilegi di amministratore per procedere. Ora, esegui il seguente comando al prompt dei comandi:

piattaforma	Comando e output	Descrizione
finestre	\> java -jar scala-2.13.1-installer.jar \>	Questo comando mostrerà una procedura guidata di installazione, che ti guiderà all'installazione di Scala sulla tua macchina Windows. Durante l'installazione, chiederà un contratto di licenza, semplicemente accettalo e inoltre chiederà un percorso in cui verrà installato Scala. Ho selezionato il percorso predefinito "C: \ Programmi \ Scala", puoi selezionare un percorso adatto secondo la tua convenienza.
Linux	Command - $ java -jar scala-2.13.1-installer.jar Output - Benvenuti all'installazione di Scala 2.13.1! La homepage è a - http://Scala-lang.org/ premere 1 per continuare, 2 per uscire, 3 per rivisualizzare 1 ................................................ [Avvio del disimballaggio] [Pacchetto di elaborazione: installazione del pacchetto software (1/1)] [Disimballaggio terminato] [Installazione della console completata]	Durante l'installazione, chiederà il contratto di licenza, per accettarlo digita 1 e chiederà un percorso in cui verrà installato Scala. Ho inserito / usr / local / share, puoi selezionare un percorso adatto secondo la tua convenienza.

Infine, apri un nuovo prompt dei comandi e digita Scala -versione premere Invio. Dovresti vedere quanto segue:

piattaforma	Comando	Produzione
finestre	\> scala -version	Scala code runner versione 2.13.1 - Copyright 2002-2019, LAMP / EPFL e Lightbend, Inc.
Linux	$ scala -version	Scala code runner versione 2.13.1 - Copyright 2002-2019, LAMP / EPFL e Lightbend, Inc.tut

Scala fornisce una struttura dati, la array, che archivia una raccolta sequenziale a dimensione fissa di elementi dello stesso tipo. Un array viene utilizzato per memorizzare una raccolta di dati, ma spesso è più utile pensare a un array come una raccolta di variabili dello stesso tipo.

Invece di dichiarare variabili individuali, come numero0, numero1, ... e numero99, dichiari una variabile di matrice come numeri e utilizzi numeri [0], numeri [1] e ..., numeri [99] per rappresentare variabili individuali. Questo tutorial introduce come dichiarare variabili di array, creare array ed elaborare array utilizzando variabili indicizzate. L'indice del primo elemento di un array è il numero zero e l'indice dell'ultimo elemento è il numero totale di elementi meno uno.

Dichiarazione di variabili array

Per utilizzare un array in un programma, è necessario dichiarare una variabile per fare riferimento all'array e specificare il tipo di array a cui la variabile può fare riferimento.

La seguente è la sintassi per la dichiarazione di una variabile di matrice.

Sintassi

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

Qui, z è dichiarato come un array di stringhe che può contenere fino a tre elementi. I valori possono essere assegnati a singoli elementi o ottenere l'accesso a singoli elementi, può essere fatto utilizzando comandi come i seguenti:

Comando

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Qui, l'ultimo esempio mostra che in generale l'indice può essere qualsiasi espressione che restituisce un numero intero. C'è un altro modo per definire un array:

var z = Array("Zara", "Nuha", "Ayan")

L'immagine seguente rappresenta un array myList. Qui,myList contiene dieci valori doppi e gli indici vanno da 0 a 9.

Elaborazione di array

Quando elaboriamo gli elementi di un array, usiamo spesso strutture di controllo del ciclo perché tutti gli elementi in un array sono dello stesso tipo e la dimensione dell'array è nota.

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare array:

Esempio

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }
      // Summing all elements
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);
      // Finding the largest element
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("Max is " + max);
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala non supporta direttamente varie operazioni sugli array e fornisce vari metodi per elaborare gli array in qualsiasi dimensione. Se si desidera utilizzare i diversi metodi, è necessario importareArray._ pacchetto.

Esistono molte situazioni in cui è necessario definire e utilizzare array multidimensionali (cioè array i cui elementi sono array). Ad esempio, matrici e tabelle sono esempi di strutture che possono essere realizzate come array bidimensionali.

Di seguito è riportato l'esempio di definizione di un array bidimensionale:

var myMatrix = ofDim[Int](3,3)

Questo è un array che ha tre elementi, ciascuno dei quali è un array di numeri interi che ha tre elementi.

Prova il seguente programma di esempio per elaborare un array multidimensionale:

Esempio

import Array._
object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

0 1 2
0 1 2
0 1 2

Uso del metodo range () per generare un array contenente una sequenza di numeri interi crescenti in un dato intervallo. È possibile utilizzare l'argomento finale come passaggio per creare la sequenza; se non si utilizza l'argomento finale, si presume che step sia 1.

Facciamo un esempio di creazione di un array di intervallo (10, 20, 2): significa creare un array con elementi tra 10 e 20 e differenza di intervallo 2. Gli elementi dell'array sono 10, 12, 14, 16 e 18 .

Un altro esempio: range (10, 20). Qui la differenza di intervallo non è data, quindi per impostazione predefinita assume 1 elemento. Crea un array con gli elementi compresi tra 10 e 20 con differenza di intervallo 1. Gli elementi nell'array sono 10, 11, 12, 13, ... e 19.

Il seguente programma di esempio mostra come creare un array con intervalli.

Esempio

import Array._
object Demo {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)
      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Scala fornisce una struttura dati, la ArrayBuffer, che può cambiare dimensione quando la dimensione iniziale è inferiore. Poiché l'array ha una dimensione fissa e non è possibile occupare più elementi in un array, ArrayBuffer è un'alternativa all'array in cui la dimensione è flessibile.

ArrayBuffer mantiene internamente un array della dimensione corrente per memorizzare gli elementi. Quando viene aggiunto un nuovo elemento, la dimensione viene controllata. Nel caso in cui l'array sottostante sia pieno, viene creato un nuovo array più grande e tutti gli elementi vengono copiati in un array più grande.

Dichiarazione delle variabili ArrayBuffer

La seguente è la sintassi per dichiarare una variabile ArrayBuffer.

Sintassi

var z = ArrayBuffer[String]()

Qui, z è dichiarato come un array-buffer di stringhe che inizialmente è vuoto. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

z += "Zara";
z += "Nuha";
z += "Ayan";

Elaborazione di ArrayBuffer

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare ArrayBuffer -

Esempio

import scala.collection.mutable.ArrayBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ArrayBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

ArrayBuffer(Zara, Nuha, Ayan)
ArrayBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

Gli elenchi Scala sono abbastanza simili agli array, il che significa che tutti gli elementi di un elenco hanno lo stesso tipo ma ci sono due differenze importanti. Innanzitutto, gli elenchi sono immutabili, il che significa che gli elementi di un elenco non possono essere modificati per assegnazione. In secondo luogo, gli elenchi rappresentano un elenco collegato mentre gli array sono piatti.

Il tipo di un elenco che contiene elementi di tipo T è scritto come List[T].

Prova il seguente esempio, ecco alcuni elenchi definiti per vari tipi di dati.

// List of Strings
val fruit: List[String] = List("apples", "oranges", "pears")
// List of Integers
val nums: List[Int] = List(1, 2, 3, 4)
// Empty List.
val empty: List[Nothing] = List()
// Two dimensional list
val dim: List[List[Int]] = List(
   List(1, 0, 0),
   List(0, 1, 0),
   List(0, 0, 1)
)

Tutti gli elenchi possono essere definiti utilizzando due elementi costitutivi fondamentali, una coda Nil e ::, che è pronunciato cons. Nil rappresenta anche l'elenco vuoto. Tutti gli elenchi di cui sopra possono essere definiti come segue.

// List of Strings
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
// List of Integers
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
// Empty List.
val empty = Nil
// Two dimensional list
val dim = (1 :: (0 :: (0 :: Nil))) ::
   (0 :: (1 :: (0 :: Nil))) ::
   (0 :: (0 :: (1 :: Nil))) :: Nil

Operazioni di base sugli elenchi

Tutte le operazioni sulle liste possono essere espresse nei termini delle seguenti tre modalità.

Suor n	Metodi e descrizione
1	head Questo metodo restituisce il primo elemento di una lista.
2	tail Questo metodo restituisce un elenco composto da tutti gli elementi tranne il primo.
3	isEmpty Questo metodo restituisce true se l'elenco è vuoto, altrimenti false.

Il seguente esempio mostra come utilizzare i metodi precedenti.

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      val nums = Nil
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Head of fruit : apples
Tail of fruit : List(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

Elenchi concatenati

Puoi usare entrambi ::: operatore o List.:::() metodo o List.concat()metodo per aggiungere due o più elenchi. Si prega di trovare il seguente esempio riportato di seguito:

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit1 = "apples" :: ("oranges" :: ("pears" :: Nil))
      val fruit2 = "mangoes" :: ("banana" :: Nil)
      // use two or more lists with ::: operator
      var fruit = fruit1 ::: fruit2
      println( "fruit1 ::: fruit2 : " + fruit )
      // use two lists with Set.:::() method
      fruit = fruit1.:::(fruit2)
      println( "fruit1.:::(fruit2) : " + fruit )
      // pass two or more lists as arguments
      fruit = List.concat(fruit1, fruit2)
      println( "List.concat(fruit1, fruit2) : " + fruit  )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

fruit1 ::: fruit2 : List(apples, oranges, pears, mangoes, banana)
fruit1.:::(fruit2) : List(mangoes, banana, apples, oranges, pears)
List.concat(fruit1, fruit2) : List(apples, oranges, pears, mangoes, banana)

Creazione di elenchi uniformi

Puoi usare List.fill()Il metodo crea una lista composta da zero o più copie dello stesso elemento. Prova il seguente programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit = List.fill(3)("apples") // Repeats apples three times.
      println( "fruit : " + fruit  )
      val num = List.fill(10)(2)         // Repeats 2, 10 times.
      println( "num : " + num  )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

fruit : List(apples, apples, apples)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)

Tabulare una funzione

Puoi usare una funzione insieme a List.tabulate()metodo da applicare su tutti gli elementi della lista prima di tabulare la lista. I suoi argomenti sono proprio come quelli di List.fill: il primo argomento list fornisce le dimensioni della lista da creare, e il secondo descrive gli elementi della lista. L'unica differenza è che invece di fissare gli elementi, vengono calcolati da una funzione.

Prova il seguente programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      // Creates 5 elements using the given function.
      val squares = List.tabulate(6)(n => n * n)
      println( "squares : " + squares  )
      val mul = List.tabulate( 4,5 )( _ * _ )      
      println( "mul : " + mul  )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

squares : List(0, 1, 4, 9, 16, 25)
mul : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), 
   List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))

Ordine elenco inverso

Puoi usare List.reversemetodo per invertire tutti gli elementi della lista. L'esempio seguente mostra l'utilizzo.

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
      println( "Before reverse fruit : " + fruit )
      println( "After reverse fruit : " + fruit.reverse )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Before reverse fruit : List(apples, oranges, pears)
After reverse fruit : List(pears, oranges, apples)

Scala fornisce una struttura dati, la ListBuffer, che è più efficiente di List durante l'aggiunta / rimozione di elementi in un elenco. Fornisce metodi per anteporre e aggiungere elementi a un elenco.

Dichiarazione delle variabili ListBuffer

Di seguito è riportata la sintassi per la dichiarazione di una variabile ListBuffer.

Sintassi

var z = ListBuffer[String]()

Qui, z è dichiarato come un buffer di lista di stringhe che inizialmente è vuoto. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

z += "Zara";
z += "Nuha";
z += "Ayan";

Elaborazione ListBuffer

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare ListBuffer -

Esempio

import scala.collection.mutable.ListBuffer 
object Demo {
   def main(args: Array[String]) = {
      var myList = ListBuffer("Zara","Nuha","Ayan")
      println(myList);
      // Add an element
      myList += "Welcome";
      // Add two element
      myList += ("To", "Tutorialspoint");
      println(myList);
      // Remove an element
      myList -= "Welcome";
      // print second element
      println(myList(1));
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

ListBuffer(Zara, Nuha, Ayan)
ListBuffer(Zara, Nuha, Ayan, Welcome, To, Tutorialspoint)
Nuha

Scala Set è una raccolta di elementi diversi a coppie dello stesso tipo. In altre parole, un Set è una raccolta che non contiene elementi duplicati. ListSet implementa set non modificabili e utilizza la struttura dell'elenco. L'ordine di inserimento degli elementi viene mantenuto durante la memorizzazione degli elementi.

Dichiarazione delle variabili ListSet

La seguente è la sintassi per dichiarare una variabile ListSet.

Sintassi

var z : ListSet[String] = ListSet("Zara","Nuha","Ayan")

Qui, z è dichiarato come un insieme di elenchi di stringhe che ha tre membri. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myList1: ListSet[String] = myList + "Naira";

Elaborazione ListSet

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare ListSet -

Esempio

import scala.collection.immutable.ListSet
object Demo {
   def main(args: Array[String]) = {
      var myList: ListSet[String] = ListSet("Zara","Nuha","Ayan");
      // Add an element
      var myList1: ListSet[String] = myList + "Naira";
      // Remove an element
      var myList2: ListSet[String] = myList - "Nuha";
      // Create empty set
      var myList3: ListSet[String] = ListSet.empty[String];
      println(myList);
      println(myList1);
      println(myList2);
      println(myList3);	  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

ListSet(Zara, Nuha, Ayan)
ListSet(Zara, Nuha, Ayan, Naira)
ListSet(Zara, Ayan)
ListSet()

Scala Vector è una struttura dati immutabile per scopi generali in cui è possibile accedere agli elementi in modo casuale. Viene generalmente utilizzato per grandi raccolte di dati.

Dichiarazione di variabili vettoriali

La seguente è la sintassi per la dichiarazione di una variabile Vector.

Sintassi

var z : Vector[String] = Vector("Zara","Nuha","Ayan")

Qui, z è dichiarato come un vettore di stringhe che ha tre membri. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var vector1: Vector[String] = z + "Naira";

Vettore di elaborazione

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare Vector -

Esempio

import scala.collection.immutable.Vector
object Demo {
   def main(args: Array[String]) = {
      var vector: Vector[String] = Vector("Zara","Nuha","Ayan");
      // Add an element
      var vector1: Vector[String] = vector :+ "Naira";
      // Reverse an element
      var vector2: Vector[String] = vector.reverse;
      // sort a vector
      var vector3: Vector[String] = vector1.sorted;
      println(vector);
      println(vector1);
      println(vector2);
      println(vector3);	  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Vector(Zara, Nuha, Ayan)
Vector(Zara, Nuha, Ayan, Naira)
Vector(Ayan, Nuha, Zara)
Vector(Ayan, Naira, Nuha, Zara)

Scala Set è una raccolta di elementi diversi a coppie dello stesso tipo. In altre parole, un Set è una raccolta che non contiene elementi duplicati. Esistono due tipi di Set, iimmutable e il mutable. La differenza tra oggetti mutabili e immutabili è che quando un oggetto è immutabile, l'oggetto stesso non può essere modificato.

Per impostazione predefinita, Scala utilizza il set immutabile. Se vuoi usare il set mutabile, dovrai importarescala.collection.mutable.Setclass esplicitamente. Se desideri utilizzare sia l'insieme mutabile che quello immutabile nella stessa raccolta, puoi continuare a fare riferimento all'insieme immutabile comeSet ma puoi fare riferimento al set mutevole come mutable.Set.

Ecco come puoi dichiarare insiemi immutabili:

Sintassi

// Empty set of integer type
var s : Set[Int] = Set()
// Set of integer type
var s : Set[Int] = Set(1,3,5,7)

or 

var s = Set(1,3,5,7)

Durante la definizione di un insieme vuoto, l'annotazione del tipo è necessaria poiché il sistema deve assegnare un tipo concreto alla variabile.

Operazioni di base sul set

Tutte le operazioni sugli insiemi possono essere espresse nei termini dei seguenti tre metodi:

Suor n	Metodi e descrizione
1	head Questo metodo restituisce il primo elemento di un set.
2	tail Questo metodo restituisce un set composto da tutti gli elementi tranne il primo.
3	isEmpty Questo metodo restituisce true se il set è vuoto, altrimenti false.

Prova il seguente esempio che mostra l'utilizzo dei metodi operativi di base:

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit = Set("apples", "oranges", "pears")
      val nums: Set[Int] = Set()
      println( "Head of fruit : " + fruit.head )
      println( "Tail of fruit : " + fruit.tail )
      println( "Check if fruit is empty : " + fruit.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Head of fruit : apples
Tail of fruit : Set(oranges, pears)
Check if fruit is empty : false
Check if nums is empty : true

Set concatenati

Puoi usare entrambi ++ operatore o Set.++() metodo per concatenare due o più set, ma durante l'aggiunta di set rimuoverà gli elementi duplicati.

Il seguente è l'esempio per concatenare due set.

Esempio

object Demo {
   def main(args: Array[String]) {
      val fruit1 = Set("apples", "oranges", "pears")
      val fruit2 = Set("mangoes", "banana")
      // use two or more sets with ++ as operator
      var fruit = fruit1 ++ fruit2
      println( "fruit1 ++ fruit2 : " + fruit )
      // use two sets with ++ as method
      fruit = fruit1.++(fruit2)
      println( "fruit1.++(fruit2) : " + fruit )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

fruit1 ++ fruit2 : Set(banana, apples, mangoes, pears, oranges)
fruit1.++(fruit2) : Set(banana, apples, mangoes, pears, oranges)

Trova gli elementi massimi e minimi in un set

Puoi usare Set.min metodo per scoprire il minimo e Set.maxmetodo per scoprire il massimo degli elementi disponibili in un set. Di seguito è riportato l'esempio per mostrare il programma.

Esempio

object Demo {
   def main(args: Array[String]) {
      val num = Set(5,6,9,20,30,45)
      // find min and max of the elements
      println( "Min element in Set(5,6,9,20,30,45) : " + num.min )
      println( "Max element in Set(5,6,9,20,30,45) : " + num.max )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Min element in Set(5,6,9,20,30,45) : 5
Max element in Set(5,6,9,20,30,45) : 45

Trova inserti di valori comuni

Puoi usare entrambi Set.& metodo o Set.intersectmetodo per scoprire i valori comuni tra due insiemi. Prova il seguente esempio per mostrare l'utilizzo.

Esempio

object Demo {
   def main(args: Array[String]) {
      val num1 = Set(5,6,9,20,30,45)
      val num2 = Set(50,60,9,20,35,55)
      // find common elements between two sets
      println( "num1.&(num2) : " + num1.&(num2) )
      println( "num1.intersect(num2) : " + num1.intersect(num2) )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

num1.&(num2) : Set(20, 9)
num1.intersect(num2) : Set(20, 9)

Bitset è una classe base comune per set di bit modificabili e immutabili. I set di bit sono insiemi di numeri interi non negativi e sono rappresentati come array di bit di dimensione variabile racchiusi in parole a 64 bit. L'impronta di memoria di un set di bit è rappresentata dal numero più grande in esso memorizzato.

Dichiarazione di variabili BitSet

La seguente è la sintassi per dichiarare una variabile BitSet.

Sintassi

var z : BitSet = BitSet(0,1,2)

Qui, z è dichiarato come un insieme di bit di interi non negativi che ha tre membri. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myList1: BitSet = myList + 3;

Elaborazione di BitSet

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare BitSet -

Esempio

import scala.collection.immutable.BitSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: BitSet = BitSet(0, 1, 2);
      // Add an element
      var mySet1: BitSet = mySet + 3;
      // Remove an element
      var mySet2: BitSet = mySet - 2;
      var mySet3: BitSet = BitSet(4, 5);
      // Adding sets
      var mySet4: BitSet = mySet1 ++ mySet3;
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet4);	  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

BitSet(0, 1, 2)
BitSet(0, 1, 2, 3)
BitSet(0, 1)
BitSet(0, 1, 2, 3, 4, 5)

Scala Set è una raccolta di elementi diversi a coppie dello stesso tipo. In altre parole, un Set è una raccolta che non contiene elementi duplicati. HashSet implementa set non modificabili e utilizza una tabella hash. L'ordine di inserimento degli elementi non viene mantenuto.

Dichiarazione delle variabili HashSet

La seguente è la sintassi per dichiarare una variabile HashSet.

Sintassi

var z : HashSet[String] = HashSet("Zara","Nuha","Ayan")

Qui, z è dichiarato come un insieme di hash di stringhe che ha tre membri. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myList1: HashSet[String] = myList + "Naira";

Elaborazione di HashSet

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare HashSet -

Esempio

import scala.collection.immutable.HashSet
object Demo {
   def main(args: Array[String]) = {
      var mySet: HashSet[String] = HashSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: HashSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: HashSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: HashSet[String] = HashSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

HashSet(Zara, Nuha, Ayan)
HashSet(Zara, Nuha, Ayan, Naira)
HashSet(Zara, Ayan)
HashSet()

Scala Set è una raccolta di elementi diversi a coppie dello stesso tipo. In altre parole, un Set è una raccolta che non contiene elementi duplicati. TreeSet implementa set non modificabili e mantiene gli elementi in ordine ordinato.

Dichiarazione delle variabili TreeSet

Di seguito è riportata la sintassi per la dichiarazione di una variabile TreeSet.

Sintassi

var z : TreeSet[String] = TreeSet("Zara","Nuha","Ayan")

Qui, z è dichiarato come un insieme di stringhe ad albero che ha tre membri. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myList1: TreeSet[String] = myList + "Naira";

Elaborazione TreeSet

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare TreeSet -

Esempio

import scala.collection.immutable.TreeSet

object Demo {
   def main(args: Array[String]) = {
      var mySet: TreeSet[String] = TreeSet("Zara","Nuha","Ayan");
      // Add an element
      var mySet1: TreeSet[String] = mySet + "Naira";
      // Remove an element
      var mySet2: TreeSet[String] = mySet - "Nuha";
      // Create empty set
      var mySet3: TreeSet[String] = TreeSet.empty[String];
      println(mySet);
      println(mySet1);
      println(mySet2);
      println(mySet3);	  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

TreeSet(Ayan, Nuha, Zara)
TreeSet(Ayan, Naira, Nuha, Zara)
TreeSet(Ayan, Zara)
TreeSet()

Scala map è una raccolta di coppie chiave / valore. Qualsiasi valore può essere recuperato in base alla sua chiave. Le chiavi sono uniche nella mappa, ma i valori non devono essere univoci. Le mappe sono anche chiamate tabelle hash. Esistono due tipi di mappe, leimmutable e il mutable. La differenza tra oggetti mutabili e immutabili è che quando un oggetto è immutabile, l'oggetto stesso non può essere modificato.

Per impostazione predefinita, Scala utilizza la mappa immutabile. Se vuoi usare la mappa mutevole, dovrai importarescala.collection.mutable.Mapclass esplicitamente. Se desideri utilizzare mappe modificabili e immutabili nella stessa, puoi continuare a fare riferimento alla mappa immutabile comeMap ma puoi fare riferimento al set mutabile come mutable.Map.

Di seguito sono riportate le istruzioni di esempio per dichiarare Maps immutabile -

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Durante la definizione della mappa vuota, l'annotazione del tipo è necessaria poiché il sistema deve assegnare un tipo concreto alla variabile. Se vogliamo aggiungere una coppia chiave-valore a una mappa, possiamo utilizzare l'operatore + come segue.

A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)

Operazioni di base su MAP

Tutte le operazioni sulle mappe possono essere espresse nei termini dei seguenti tre metodi.

Suor n	Metodi e descrizione
1	keys Questo metodo restituisce un iterabile contenente ogni chiave nella mappa.
2	values Questo metodo restituisce un iterabile contenente ogni valore nella mappa.
3	isEmpty Questo metodo restituisce true se la mappa è vuota, altrimenti false.

Prova il seguente programma di esempio che mostra l'utilizzo dei metodi Map.

Esempio

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val nums: Map[Int, Int] = Map()
      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

Mappe concatenate

Puoi usare entrambi ++ operatore o Map.++() metodo per concatenare due o più mappe, ma durante l'aggiunta di mappe rimuoverà le chiavi duplicate.

Prova il seguente programma di esempio per concatenare due mappe.

Esempio

object Demo {
   def main(args: Array[String]) {
      val colors1 = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      val colors2 = Map(
         "blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000"
      )
      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )
      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

Stampa chiavi e valori da una mappa

Puoi scorrere le chiavi e i valori di una mappa utilizzando il ciclo "foreach". Qui abbiamo usato il metodoforeachassociato all'iteratore per scorrere le chiavi. Di seguito è riportato il programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{
         i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )
      }
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

Verificare la presenza di una chiave in Map

Puoi usare entrambi Map.containsmetodo per verificare se una determinata chiave esiste o meno nella mappa. Prova il seguente programma di esempio per il controllo delle chiavi.

Esempio

object Demo {
   def main(args: Array[String]) {
      val colors = Map(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      )
      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
         println("Red key does not exist")
      }
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Red key exists with value :#FF0000
Maroon key does not exist

Dichiarazione delle variabili HashMap

La seguente è la sintassi per dichiarare una variabile HashMap.

Sintassi

val colors = HashMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

Qui, i colori sono dichiarati come una mappa hash di Strings, Int che ha tre coppie chiave-valore. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myMap1: HashMap[Char, Int] = colors + ("black" -> "#000000");

Elaborazione di HashMap

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare HashMap -

Esempio

import scala.collection.immutable.HashMap
object Demo {
   def main(args: Array[String]) = {
      var myMap: HashMap[String,String] = HashMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: HashMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) )
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: HashMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: HashMap[String,String] = HashMap.empty[String, String];
      println(myMap1);
      println(myMap2);
      println(myMap3);		  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Key = red Value = #FF0000
Red key exists with value :#FF0000
Maroon key does not exist
HashMap(azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF, red -> #FF0000)
HashMap(azure -> #F0FFFF, peru -> #CD853F, red -> #FF0000)
HashMap()

Scala map è una raccolta di coppie chiave / valore. Qualsiasi valore può essere recuperato in base alla sua chiave. Le chiavi sono uniche nella mappa, ma i valori non devono essere univoci. ListMap implementa la mappa immutabile e utilizza list per implementarla. Viene utilizzato con un numero ridotto di elementi.

Dichiarazione delle variabili ListMap

La seguente è la sintassi per la dichiarazione di una variabile ListMap.

Sintassi

val colors = ListMap("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

Qui, i colori sono dichiarati come una mappa hash di Strings, Int che ha tre coppie chiave-valore. I valori possono essere aggiunti utilizzando comandi come i seguenti:

Comando

var myMap1: ListMap[Char, Int] = colors + ("black" -> "#000000");

Elaborazione ListMap

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare ListMap -

Esempio

import scala.collection.immutable.ListMap

object Demo {
   def main(args: Array[String]) = {
      var myMap: ListMap[String,String] = ListMap(
         "red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F"
      );
      // Add an element
      var myMap1: ListMap[String,String] = myMap + ("white" -> "#FFFFFF");
      // Print key values
      myMap.keys.foreach{ 
         i =>  
         print( "Key = " + i )
         println(" Value = " + myMap(i) ) 
      }
      if( myMap.contains( "red" )) {
         println("Red key exists with value :"  + myMap("red"))
      } else {
         println("Red key does not exist")
      }
      if( myMap.contains( "maroon" )) {
         println("Maroon key exists with value :"  + myMap("maroon"))
      } else {
         println("Maroon key does not exist")
      }
      //removing element
      var myMap2: ListMap[String,String] = myMap - ("white");
      // Create empty map
      var myMap3: ListMap[String,String] = ListMap.empty[String, String];
      println(myMap1);
      println(myMap2);	
      println(myMap3);		  
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F
Red key exists with value :#FF0000
Maroon key does not exist
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F, white -> #FFFFFF)
ListMap(red -> #FF0000, azure -> #F0FFFF, peru -> #CD853F)
ListMap()

Un iteratore non è una raccolta, ma piuttosto un modo per accedere agli elementi di una raccolta uno per uno. Le due operazioni di base su un fileiterator it siamo next e hasNext. Una chiamata ait.next()restituirà l'elemento successivo dell'iteratore e farà avanzare lo stato dell'iteratore. Puoi scoprire se ci sono più elementi da restituire usando Iteratorit.hasNext metodo.

Il modo più semplice per "scorrere" tutti gli elementi restituiti da un iteratore è usare un ciclo while. Seguiamo il seguente programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      val it = Iterator("a", "number", "of", "words")
      while (it.hasNext){
         println(it.next())
      }
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

a
number
of
words

Trova elemento con valore minimo e massimo

Puoi usare it.min e it.maxmetodi per scoprire gli elementi con valore minimo e massimo da un iteratore. Qui, abbiamo usatoita e itbper eseguire due diverse operazioni perché l'iteratore può essere attraversato una sola volta. Di seguito è riportato il programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Maximum valued element " + ita.max )
      println("Minimum valued element " + itb.min )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Maximum valued element 90
Minimum valued element 2

Trova la lunghezza dell'iteratore

Puoi usare entrambi it.size o it.lengthmetodi per scoprire il numero di elementi disponibili in un iteratore. Qui, abbiamo usato ita e itb per eseguire due diverse operazioni perché l'iteratore può essere attraversato una sola volta. Di seguito è riportato il programma di esempio.

Esempio

object Demo {
   def main(args: Array[String]) {
      val ita = Iterator(20,40,2,50,69, 90)
      val itb = Iterator(20,40,2,50,69, 90)
      println("Value of ita.size : " + ita.size )
      println("Value of itb.length : " + itb.length )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Value of ita.size : 6
Value of itb.length : 6

L'opzione Scala [T] è un contenitore per zero o un elemento di un dato tipo. Un'opzione [T] può essere una delle dueSome[T] o Noneoggetto, che rappresenta un valore mancante. Ad esempio, il metodo get di Scala's Map produce Some (value) se è stato trovato un valore corrispondente a una data chiave, oNone se la chiave data non è definita nella mappa.

Il tipo di opzione è usato frequentemente nei programmi Scala e puoi confrontarlo con il nullvalore disponibile in Java che non indica alcun valore. Ad esempio, il metodo get di java.util.HashMap restituisce un valore memorizzato in HashMap o null se non è stato trovato alcun valore.

Supponiamo di avere un metodo che recupera un record dal database in base a una chiave primaria.

def findPerson(key: Int): Option[Person]

Il metodo restituirà Some [Person] se il record viene trovato ma None se il record non viene trovato. Seguiamo il seguente programma.

Esempio

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("capitals.get( \"France\" ) : " +  capitals.get( "France" ))
      println("capitals.get( \"India\" ) : " +  capitals.get( "India" ))
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

capitals.get( "France" ) : Some(Paris)
capitals.get( "India" ) : None

Il modo più comune per separare i valori facoltativi è attraverso una corrispondenza di pattern. Ad esempio, prova il seguente programma.

Esempio

object Demo {
   def main(args: Array[String]) {
      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
      println("show(capitals.get( \"Japan\")) : " + show(capitals.get( "Japan")) )
      println("show(capitals.get( \"India\")) : " + show(capitals.get( "India")) )
   }
   def show(x: Option[String]) = x match {
      case Some(s) => s
      case None => "?"
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

show(capitals.get( "Japan")) : Tokyo
show(capitals.get( "India")) : ?

Utilizzo del metodo getOrElse ()

Di seguito è riportato il programma di esempio per mostrare come utilizzare il metodo getOrElse () per accedere a un valore o un valore predefinito quando non è presente alcun valore.

Esempio

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.getOrElse(0): " + a.getOrElse(0) )
      println("b.getOrElse(10): " + b.getOrElse(10) )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

a.getOrElse(0): 5
b.getOrElse(10): 10

Utilizzo del metodo isEmpty ()

Di seguito è riportato il programma di esempio per mostrare come utilizzare il metodo isEmpty () per verificare se l'opzione è Nessuno o meno.

Esempio

object Demo {
   def main(args: Array[String]) {
      val a:Option[Int] = Some(5)
      val b:Option[Int] = None 
      println("a.isEmpty: " + a.isEmpty )
      println("b.isEmpty: " + b.isEmpty )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Esempio

a.isEmpty: false
b.isEmpty: true

Queue è First In First Out, struttura dati FIFO e permette di inserire e recuperare elementi in maniera FIFO.

Dichiarazione delle variabili di coda

La seguente è la sintassi per la dichiarazione di una variabile Queue.

Sintassi

val queue = Queue(1, 2, 3, 4, 5)

Qui, la coda è dichiarata come una coda di numeri. Il valore può essere aggiunto in primo piano utilizzando comandi come i seguenti:

Comando

queue.enqueue(6)

Il valore può essere recuperato in primo piano utilizzando comandi come i seguenti:

Comando

queue.dequeue()

Coda di elaborazione

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare la coda:

Esempio

import scala.collection.mutable.Queue
object Demo {
   def main(args: Array[String]) = {
      var queue = Queue(1, 2, 3, 4, 5);
      // Print queue elements
      queue.foreach{(element:Int) => print(element + " ")}
      println();
      // Print first element
      println("First Element: " + queue.front)
      // Add an element
      queue.enqueue(6);
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
      println();
      // Remove an element
      var dq = queue.dequeue;
      // Print dequeued element
      println("Dequeued Element: " + dq)
      // Print queue elements
      queue.foreach{(element:Int) => print(element+ " ")}
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

1 2 3 4 5
First Element: 1
1 2 3 4 5 6
Dequeued Element: 1
2 3 4 5 6

La tupla Scala combina un numero fisso di elementi insieme in modo che possano essere trasferiti nel loro insieme. A differenza di un array o di un elenco, una tupla può contenere oggetti con tipi diversi ma sono anche immutabili.

Il seguente è un esempio di una tupla che contiene un numero intero, una stringa e la console.

val t = (1, "hello", Console)

Che è zucchero sintattico (scorciatoia) per quanto segue -

val t = new Tuple3(1, "hello", Console)

Il tipo effettivo di una tupla dipende dal numero e dagli elementi che contiene e dai tipi di tali elementi. Pertanto, il tipo di (99, "Luftballons") è Tuple2 [Int, String]. Il tipo di ('u', 'r', "the", 1, 4, "me") è Tuple6 [Char, Char, String, Int, Int, String]

Le tuple sono di tipo Tuple1, Tuple2, Tuple3 e così via. Attualmente c'è un limite massimo di 22 in Scala se ne hai bisogno di più, puoi usare una raccolta, non una tupla. Per ogni tipo di TupleN, dove 1 <= N <= 22, Scala definisce un numero di metodi di accesso agli elementi. Data la seguente definizione:

val t = (4,3,2,1)

Per accedere agli elementi di una tupla t, è possibile utilizzare il metodo t._1 per accedere al primo elemento, t._2 per accedere al secondo e così via. Ad esempio, la seguente espressione calcola la somma di tutti gli elementi di t.

val sum = t._1 + t._2 + t._3 + t._4

È possibile utilizzare Tuple per scrivere un metodo che accetta List [Double] e restituisce il conteggio, la somma e la somma dei quadrati restituiti in una Tuple a tre elementi, una Tuple3 [Int, Double, Double]. Sono anche utili per passare un elenco di valori di dati come messaggi tra attori nella programmazione concorrente.

Prova il seguente programma di esempio. Mostra come usare una tupla.

Esempio

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      val sum = t._1 + t._2 + t._3 + t._4
      println( "Sum of elements: "  + sum )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comandi

\>scalac Demo.scala
\>scala Demo

Produzione

Sum of elements: 10

Ripeti la tupla

Puoi usare Tuple.productIterator() metodo per iterare su tutti gli elementi di una tupla.

Prova il seguente programma di esempio per iterare su tuple.

Esempio

object Demo {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comandi

\>scalac Demo.scala
\>scala Demo

Produzione

Value = 4
Value = 3
Value = 2
Value = 1

Conversione in stringa

Puoi usare Tuple.toString()metodo per concatenare tutti gli elementi della tupla in una stringa. Prova il seguente programma di esempio per convertire in String.

Esempio

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      println("Concatenated String: " + t.toString() )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Concatenated String: (1,hello,scala.Console$@281acd47)

Scambia gli elementi

Puoi usare Tuple.swap metodo per scambiare gli elementi di un Tuple2.

Prova il seguente programma di esempio per scambiare gli elementi.

Esempio

object Demo {
   def main(args: Array[String]) {
      val t = new Tuple2("Scala", "hello")
      println("Swapped Tuple: " + t.swap )
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Swapped tuple: (hello,Scala)

Scala Seq è un tratto per rappresentare sequenze immutabili. Questa struttura fornisce l'accesso basato sull'indice e vari metodi di utilità per trovare gli elementi, le loro occorrenze e le sottosequenze. Un Seq mantiene l'ordine di inserimento.

Dichiarazione delle variabili Seq

La seguente è la sintassi per la dichiarazione di una variabile Seq.

Sintassi

val seq: Seq[Int] = Seq(1, 2, 3, 4, 5)

Qui, seq è dichiarato come seq di numeri. Seq fornisce comandi come i seguenti:

Comando

val isPresent = seq.contains(4);
val contains = seq.endsWith(Seq(4,5));
var lastIndexOf = seq.lasIndexOf(5);

Elaborazione Seq

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare Seq -

Esempio

import scala.collection.immutable.Seq
object Demo {
   def main(args: Array[String]) = {
      var seq = Seq(1, 2, 3, 4, 5, 3)
      // Print seq elements
      seq.foreach{(element:Int) => print(element + " ")}
      println()
      println("Seq ends with (5,3): " + seq.endsWith(Seq(5, 3)))
      println("Seq contains 4: " + seq.contains(4))
      println("Last index of 3: " + seq.lastIndexOf(3))
      println("Reversed Seq" + seq.reverse)           
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

1 2 3 4 5 3
Seq ends with (5,3): true
Seq contains 4: true
Last index of 3: 5
Reversed SeqList(3, 5, 4, 3, 2, 1)

Stack è Last In First Out, struttura dati LIFO e permette di inserire e recuperare elementi in alto, in maniera LIFO.

Dichiarazione delle variabili di stack

La seguente è la sintassi per dichiarare una variabile Stack.

Sintassi

val stack = Stack(1, 2, 3, 4, 5)

Qui, la pila è dichiarata come una pila di numeri. Il valore può essere aggiunto in alto utilizzando comandi come i seguenti:

Comando

stack.push(6)

Il valore può essere recuperato dall'alto utilizzando comandi come i seguenti:

Comando

stack.top

Il valore può essere rimosso dall'alto utilizzando comandi come i seguenti:

Comando

stack.pop

Stack di elaborazione

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare Stack -

Esempio

import scala.collection.mutable.Stack
object Demo {
   def main(args: Array[String]) = {
      var stack: Stack[Int] = Stack();
      // Add elements
      stack.push(1);
      stack.push(2);
      // Print element at top
      println("Top Element: " + stack.top)
      // Print element
      println("Removed Element: " + stack.pop())
      // Print element
      println("Top Element: " + stack.top)	
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Top Element: 2
Removed Element: 2
Top Element: 1

Scala Stream è un elenco speciale con funzionalità di valutazione pigra. In scala stream, gli elementi vengono valutati solo quando sono necessari. Stream supporta calcoli pigri ed è esperto di prestazioni.

Dichiarazione delle variabili di flusso

La seguente è la sintassi per dichiarare una variabile Stream.

Sintassi

val stream = 1 #:: 2 #:: 3 #:: Stream.empty

Qui, stream è dichiarato come flusso di numeri. Qui 1 è l'inizio del flusso, 2, 3 sono la coda del flusso. Stream.empty segna la fine del flusso. I valori possono essere recuperati utilizzando comandi take come i seguenti:

Comando

stream.take(2)

Flusso di elaborazione

Di seguito è riportato un programma di esempio che mostra come creare, inizializzare ed elaborare Stream -

Esempio

import scala.collection.immutable.Stream
object Demo {
   def main(args: Array[String]) = {
      val stream = 1 #:: 2 #:: 3 #:: Stream.empty
      // print stream
      println(stream)
      // Print first two elements	
      stream.take(2).print
      println()
      // Create an empty stream
      val stream1: Stream[Int] = Stream.empty[Int]
      // Print element
      println(s"Stream: $stream1")
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Stream(1, <not computed>)
1, 2
Stream: Stream()

Il metodo drop () è il metodo utilizzato da List per selezionare tutti gli elementi tranne i primi n elementi della lista.

Sintassi

La seguente è la sintassi del metodo drop.

def drop(n: Int): List[A]

In questo caso n è il numero di elementi da eliminare dall'elenco. Questo metodo restituisce tutti gli elementi della lista tranne i primi n.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di rilascio:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5)
      // print list
      println(list)
      //apply operation
      val result = list.drop(3)
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(1, 2, 3, 4, 5)
List(4, 5)

Il metodo dropWhile () è il metodo utilizzato da List per eliminare tutti gli elementi che soddisfano una determinata condizione.

Sintassi

La seguente è la sintassi del metodo dropWhile.

def dropWhile(p: (A) => Boolean): List[A]

Qui, p: (A) => Boolean è un predicato o una condizione da applicare a ogni elemento della lista. Questo metodo restituisce tutti gli elementi della lista tranne quelli rilasciati.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo dropWhile:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.dropWhile(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(3, 6, 9, 4, 2)
List(4, 2)

Il metodo filter () è il metodo utilizzato da List per selezionare tutti gli elementi che soddisfano un dato predicato.

Sintassi

La seguente è la sintassi del metodo di filtro.

def filter(p: (A) => Boolean): List[A]

Qui, p: (A) => Boolean è un predicato o una condizione da applicare a ogni elemento della lista. Questo metodo restituisce tutti gli elementi della lista che soddisfano la condizione data.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di filtro:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(3, 6, 9, 4, 2)
      // print list
      println(list)
      //apply operation
      val result = list.filter(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(3, 6, 9, 4, 2)
List(3, 6, 9)

Il metodo find () è il metodo utilizzato dagli iteratori per trovare un elemento che soddisfa un dato predicato.

Sintassi

La seguente è la sintassi del metodo find.

def find(p: (A) => Boolean): Option[A]

Qui, p: (A) => Boolean è un predicato o una condizione da applicare su ogni elemento dell'iteratore. Questo metodo restituisce l'elemento Option contenente l'elemento corrispondente dell'iteratore che soddisfa la condizione data.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di ricerca:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val iterator = Iterator(3, 6, 9, 4, 2)
      //apply operation
      val result = iterator.find(x=>{x % 3 == 0})
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Some(3)

Il metodo flatMap () è il metodo del tratto TraversableLike, prende un predicato, lo applica a ogni elemento della raccolta e restituisce una nuova raccolta di elementi restituiti dal predicato.

Sintassi

Quanto segue è la sintassi del metodo flatMap.

def flatMap[B](f: (A) ? GenTraversableOnce[B]): TraversableOnce[B]

Qui, f: (A)? GenTraversableOnce [B] è un predicato o una condizione da applicare a ogni elemento della raccolta. Questo metodo restituisce l'elemento Option contenente l'elemento corrispondente dell'iteratore che soddisfa la condizione data.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo flatMap:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 5, 10)
      //apply operation
      val result = list.flatMap{x => List(x,x+1)}
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(1, 2, 5, 6, 10, 11)

Il metodo flatten () è un tratto GenericTraversableTemplate del membro, restituisce una singola raccolta di elementi unendo raccolte figlie.

Sintassi

La seguente è la sintassi del metodo flatten.

def flatten[B]: Traversable[B]

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo flatten:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(List(1,2), List(3,4))
      //apply operation
      val result = list.flatten
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(1, 2, 3, 4)

Il metodo fold () è un membro del tratto TraversableOnce, viene utilizzato per comprimere gli elementi delle raccolte.

Sintassi

La seguente è la sintassi del metodo fold.

def fold[A1 >: A](z: A1)(op: (A1, A1) ? A1): A1

Qui, il metodo fold accetta come parametro la funzione di operatore binario associativo. Questo metodo restituisce il risultato come valore. Considera il primo input come valore iniziale e il secondo input come una funzione (che prende come input il valore accumulato e l'elemento corrente).

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di piegatura:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.fold(0)(_ + _)
      //print result
      println(result)      
   }
}

Qui abbiamo passato 0 come valore iniziale alla funzione fold e quindi vengono aggiunti tutti i valori. Salva il programma sopra in formatoDemo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Il metodo foldLeft () è un membro del tratto TraversableOnce, viene utilizzato per comprimere gli elementi delle raccolte. Naviga gli elementi da sinistra a destra. Viene utilizzato principalmente nelle funzioni ricorsive e previene le eccezioni di overflow dello stack.

Sintassi

La seguente è la sintassi del metodo fold.

def foldLeft[B](z: B)(op: (B, A) ? B): B

Qui, il metodo foldLeft accetta la funzione di operatore binario associativo come parametro. Questo metodo restituisce il risultato come valore.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo foldLeft:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldLeft(0)(_ + _)
      //print result
      println(result)      
   }
}

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Il metodo foldRight () è un membro del tratto TraversableOnce, viene utilizzato per comprimere gli elementi delle raccolte. Naviga tra gli elementi da destra a sinistra.

Sintassi

La seguente è la sintassi del metodo foldRight.

def foldRight[B](z: B)(op: (B, A) ? B): B

Qui, il metodo fold accetta come parametro la funzione di operatore binario associativo. Questo metodo restituisce il valore risultante.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo foldRight:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.foldRight(0)(_ + _)
      //print result
      println(result)      
   }
}

Qui abbiamo passato 0 come valore iniziale alla funzione foldRight e quindi tutti i valori vengono aggiunti. Salva il programma sopra in formatoDemo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Il metodo map () è un membro del tratto TraversableLike, viene utilizzato per eseguire un metodo predicato su ogni elemento di una raccolta. Restituisce una nuova collezione.

Sintassi

Quanto segue è la sintassi del metodo map.

def map[B](f: (A) ? B): Traversable[B]

Qui, il metodo map accetta una funzione prediate come parametro. Questo metodo restituisce la raccolta aggiornata.

Utilizzo

Di seguito è riportato un programma di esempio per mostrare come utilizzare il metodo mappa:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get twice of each element.
      val result = list.map(_ * 2)
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(2, 4, 6, 8)

Il metodo partition () è un membro del tratto TraversableLike, viene utilizzato per eseguire un metodo predicato su ogni elemento di una raccolta. Restituisce due raccolte, una raccolta è di elementi che soddisfa una data funzione del predicato e un'altra raccolta è di elementi che non soddisfano la data funzione del predicato.

Sintassi

Quanto segue è la sintassi del metodo map.

def partition(p: (A) ? Boolean): (Repr, Repr)

In questo caso, il metodo di partizione accetta una funzione prediale come parametro. Questo metodo restituisce le raccolte.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di partizione:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3, 4, 5, 6, 7)
      //apply operation to get twice of each element.
      val (result1, result2) = list.partition(x=>{x % 3 == 0})
      //print result
      println(result1)
      println(result2)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(3, 6)
List(1, 2, 4, 5, 7)

Il metodo reduce () è un membro del tratto TraversableOnce, viene utilizzato per comprimere gli elementi delle raccolte. È simile al metodo fold ma non assume il valore iniziale.

Sintassi

La seguente è la sintassi del metodo di riduzione.

def reduce[A1 >: A](op: (A1, A1) ? A1): A1

Qui, il metodo reduce prende come parametro la funzione di operatore binario associativo. Questo metodo restituisce il valore risultante.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di piegatura:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to get sum of all elements of the list
      val result = list.reduce(_ + _)
      //print result
      println(result)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

Il metodo scan () è un membro del tratto TraversableLike, è simile al metodo fold ma viene utilizzato per applicare un'operazione su ogni elemento della raccolta e restituire una raccolta.

Sintassi

La seguente è la sintassi del metodo fold.

def scan[B >: A, That](z: B)(op: (B, B) ? B)(implicit cbf: CanBuildFrom[Repr, B, That]): That

In questo caso, il metodo di scansione accetta come parametro la funzione operatore binario associativo. Questo metodo restituisce la raccolta aggiornata come risultato. Considera il primo input come valore iniziale e il secondo input come una funzione.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo di scansione:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      //apply operation to create a running total of all elements of the list
      val list1 = list.scan(0)(_ + _)
      //print list
      println(list1)      
   }
}

Qui abbiamo passato 0 come valore iniziale per la funzione di scansione e quindi vengono aggiunti tutti i valori. Salva il programma sopra in formatoDemo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List(0, 1, 3, 6, 10)

Il metodo zip () è un membro del tratto IterableLike, viene utilizzato per unire una raccolta alla raccolta corrente e il risultato è una raccolta di una coppia di elementi della tupla da entrambe le raccolte.

Sintassi

La seguente è la sintassi del metodo zip.

def zip[B](that: GenIterable[B]): Iterable[(A, B)]

Qui, il metodo zip accetta una raccolta come parametro. Questo metodo restituisce la raccolta aggiornata della coppia come risultato.

Utilizzo

Di seguito è riportato un programma di esempio che mostra come utilizzare il metodo zip:

Esempio

object Demo {
   def main(args: Array[String]) = {
      val list = List(1, 2, 3 ,4)
      val list1 = List("A", "B", "C", "D")
      //apply operation to create a zip of list
      val list2 = list zip list1
      //print list
      println(list2)      
   }
}

Salva il programma sopra in formato Demo.scala. I seguenti comandi vengono utilizzati per compilare ed eseguire questo programma.

Comando

\>scalac Demo.scala
\>scala Demo

Produzione

List((1,A), (2,B), (3,C), (4,D))