Coleções Scala - Guia rápido

Scala tem um rico conjunto de biblioteca de coleção. Coleções são contêineres de coisas. Esses recipientes podem ser sequenciados, conjuntos lineares de itens como Lista, Tupla, Opção, Mapa, etc. As coleções podem ter um número arbitrário de elementos ou ser limitadas a zero ou um elemento (por exemplo, Opção).

As coleções podem ser strict ou lazy. As coleções lentas têm elementos que podem não consumir memória até que sejam acessadas, comoRanges. Além disso, as coleções podem sermutable (o conteúdo da referência pode mudar) ou immutable(aquilo a que uma referência se refere nunca é alterado). Observe que as coleções imutáveis podem conter itens mutáveis.

Para alguns problemas, as coleções mutáveis funcionam melhor e, para outros, as coleções imutáveis funcionam melhor. Em caso de dúvida, é melhor começar com uma coleção imutável e alterá-la mais tarde se precisar de uma coleção mutável.

Este capítulo lança luz sobre os tipos de coleção mais comumente usados e as operações mais frequentemente usadas sobre essas coleções.

Sr. Não	Coleções com Descrição
1	Scala Lists Lista de Scala [T] é uma lista vinculada do tipo T.
2	Scala Sets Um conjunto é uma coleção de elementos diferentes entre pares do mesmo tipo.
3	Scala Maps Um mapa é uma coleção de pares de chave / valor. Qualquer valor pode ser recuperado com base em sua chave.
4	Scala Tuples Ao contrário de uma matriz ou lista, uma tupla pode conter objetos com diferentes tipos.
5	Scala Options A opção [T] fornece um contêiner para zero ou um elemento de um determinado tipo.
6	Scala Iterators Um iterador não é uma coleção, mas sim uma maneira de acessar os elementos de uma coleção um por um.

Scala pode ser instalado em qualquer sistema baseado em UNIX ou Windows. Antes de iniciar a instalação do Scala em sua máquina, você deve ter o Java 1.8 ou superior instalado em seu computador.

Siga as etapas abaixo para instalar o Scala.

Etapa 1: verifique sua instalação Java

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos a seguir, dependendo da plataforma em que está trabalhando.

Se a instalação do Java foi feita corretamente, ele exibirá a versão atual e as especificações de sua instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.

Plataforma	Comando	Saída de amostra
janelas	Abra o console de comando e digite - \>java -version	Versão Java "1.8.0_31" Tempo de execução Java (TM) SE Ambiente (versão 1.8.0_31-b31) Servidor Java Hotspot (TM) de 64 bits VM (versão 25.31-b07, modo misto)
Linux	Abra o terminal de comando e digite - $java -version	Versão Java "1.8.0_31" Ambiente de tempo de execução JDK aberto (rhel-2.8.10.4.el6_4-x86_64) Abra o servidor VM JDK de 64 bits (versão 25.31-b07, modo misto)

Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.8.0_31 instalado em seus sistemas.

Caso você não tenha Java SDK, baixe sua versão atual em https://www.oracle.com/technetwork/java/javase/downloads/index.html e instale-o.

Etapa 2: definir seu ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

Sr. Não	Plataforma e descrição
1	Windows Defina JAVA_HOME como C: \ ProgramFiles \ java \ jdk1.8.0_31
2	Linux Exportar JAVA_HOME = / usr / local / java-current

Anexe o caminho completo do local do compilador Java ao caminho do sistema.

Sr. Não	Plataforma e descrição
1	Windows Anexe a string "C: \ Arquivos de programas \ Java \ jdk1.8.0_31 \ bin" ao final da variável de sistema PATH.
2	Linux Exportar PATH = $ PATH: $ JAVA_HOME / bin /

Execute o comando java -version no prompt de comando, conforme explicado acima.

Etapa 3: Instale o Scala

Você pode baixar o Scala em www.scala-lang.org/downloads . No momento em que escrevi este tutorial, eu baixei 'scala-2.13.1-installer.jar'. Certifique-se de ter privilégios de administrador para continuar. Agora, execute o seguinte comando no prompt de comando -

Plataforma	Comando e Saída	Descrição
janelas	\> java -jar scala-2.13.1-installer.jar \>	Este comando exibirá um assistente de instalação, que o guiará na instalação do Scala em sua máquina Windows. Durante a instalação, ele solicitará um contrato de licença, simplesmente aceite-o e, em seguida, ele solicitará um caminho onde o Scala será instalado. Selecionei o caminho padrão fornecido "C: \ Arquivos de programas \ Scala", você pode selecionar um caminho adequado conforme sua conveniência.
Linux	Command - $ java -jar scala-2.13.1-installer.jar Output - Bem-vindo à instalação do Scala 2.13.1! A página inicial está em - http://Scala-lang.org/ pressione 1 para continuar, 2 para sair, 3 para exibir novamente 1 ................................................ [Começando a desempacotar] [Processando pacote: Instalação do Pacote de Software (1/1)] [Desembalagem concluída] [Instalação do console concluída]	Durante a instalação, ele pedirá um contrato de licença, para aceitá-lo digite 1 e pedirá um caminho onde o Scala será instalado. Entrei em / usr / local / share, você pode selecionar um caminho adequado de acordo com sua conveniência.

Por fim, abra um novo prompt de comando e digite Scala -versione pressione Enter. Você deve ver o seguinte -

Plataforma	Comando	Resultado
janelas	\> scala -version	Scala code runner versão 2.13.1 - Copyright 2002-2019, LAMP / EPFL e Lightbend, Inc.
Linux	$ scala -version	Scala code runner versão 2.13.1 - Copyright 2002-2019, LAMP / EPFL e Lightbend, Inc.tut

Scala fornece uma estrutura de dados, o array, que armazena uma coleção sequencial de tamanho fixo de elementos do mesmo tipo. Uma matriz é usada para armazenar uma coleção de dados, mas geralmente é mais útil pensar em uma matriz como uma coleção de variáveis do mesmo tipo.

Em vez de declarar variáveis individuais, como número0, número1, ... e número99, você declara uma variável de matriz, como números e usa números [0], números [1] e ..., números [99] para representar variáveis individuais. Este tutorial apresenta como declarar variáveis de array, criar arrays e processar arrays usando variáveis indexadas. O índice do primeiro elemento de uma matriz é o número zero e o índice do último elemento é o número total de elementos menos um.

Declarando Variáveis de Matriz

Para usar uma matriz em um programa, você deve declarar uma variável para fazer referência à matriz e deve especificar o tipo de matriz que a variável pode fazer referência.

A seguir está a sintaxe para declarar uma variável de matriz.

Sintaxe

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

or

var z = new Array[String](3)

Aqui, z é declarado como uma matriz de Strings que pode conter até três elementos. Os valores podem ser atribuídos a elementos individuais ou obter acesso a elementos individuais, isso pode ser feito usando comandos como o seguinte -

Comando

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

Aqui, o último exemplo mostra que, em geral, o índice pode ser qualquer expressão que produza um número inteiro. Existe mais uma maneira de definir uma matriz -

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

A imagem a seguir representa uma matriz myList. Aqui,myList possui dez valores duplos e os índices vão de 0 a 9.

Processando matrizes

Ao processar elementos de array, frequentemente usamos estruturas de controle de loop porque todos os elementos em um array são do mesmo tipo e o tamanho do array é conhecido.

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar matrizes -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala não suporta diretamente várias operações de array e fornece vários métodos para processar arrays em qualquer dimensão. Se você quiser usar os diferentes métodos, é necessário importarArray._ pacote.

Existem muitas situações em que você precisaria definir e usar arrays multidimensionais (ou seja, arrays cujos elementos são arrays). Por exemplo, matrizes e tabelas são exemplos de estruturas que podem ser realizadas como matrizes bidimensionais.

A seguir está o exemplo de definição de uma matriz bidimensional -

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

Este é um array com três elementos, cada um sendo um array de inteiros com três elementos.

Experimente o programa de exemplo a seguir para processar uma matriz multidimensional -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

0 1 2
0 1 2
0 1 2

Uso do método range () para gerar uma matriz contendo uma sequência de números inteiros crescentes em um determinado intervalo. Você pode usar o argumento final como etapa para criar a sequência; se você não usar o argumento final, o passo será assumido como 1.

Vejamos um exemplo de criação de uma matriz de intervalo (10, 20, 2): Significa criar uma matriz com elementos entre 10 e 20 e diferença de intervalo 2. Os elementos da matriz são 10, 12, 14, 16 e 18 .

Outro exemplo: intervalo (10, 20). Aqui a diferença de intervalo não é fornecida, por padrão, assume 1 elemento. Ele cria uma matriz com os elementos entre 10 e 20 com diferença de intervalo 1. Os elementos da matriz são 10, 11, 12, 13, ... e 19.

O programa de exemplo a seguir mostra como criar uma matriz com intervalos.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala fornece uma estrutura de dados, o ArrayBuffer, que pode mudar de tamanho quando o tamanho inicial for insuficiente. Como o array tem um tamanho fixo e mais elementos não podem ser ocupados em um array, ArrayBuffer é uma alternativa para o array onde o tamanho é flexível.

Internamente, o ArrayBuffer mantém uma matriz do tamanho atual para armazenar elementos. Quando um novo elemento é adicionado, o tamanho é verificado. No caso do array subjacente estar cheio, um novo array maior é criado e todos os elementos são copiados para um array maior.

Declarando Variáveis ArrayBuffer

A seguir está a sintaxe para declarar uma variável ArrayBuffer.

Sintaxe

var z = ArrayBuffer[String]()

Aqui, z é declarado como um buffer de matriz de Strings que está inicialmente vazio. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando ArrayBuffer

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar ArrayBuffer -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Lists são bastante semelhantes a arrays, o que significa que todos os elementos de uma lista têm o mesmo tipo, mas existem duas diferenças importantes. Primeiro, as listas são imutáveis, o que significa que os elementos de uma lista não podem ser alterados por atribuição. Em segundo lugar, as listas representam uma lista vinculada, enquanto as matrizes são simples.

O tipo de lista que possui elementos do tipo T é escrito como List[T].

Tente o exemplo a seguir, aqui estão algumas listas definidas para vários tipos de dados.

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

Todas as listas podem ser definidas usando dois blocos de construção fundamentais, uma cauda Nil e ::, que é pronunciado cons. Nil também representa a lista vazia. Todas as listas acima podem ser definidas como 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

Operações básicas em listas

Todas as operações nas listas podem ser expressas em termos dos três métodos a seguir.

Sr. Não	Métodos e Descrição
1	head Este método retorna o primeiro elemento de uma lista.
2	tail Este método retorna uma lista que consiste em todos os elementos, exceto o primeiro.
3	isEmpty Este método retorna verdadeiro se a lista estiver vazia, caso contrário, é falso.

O exemplo a seguir mostra como usar os métodos acima.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Listas de concatenação

Você pode usar qualquer ::: operador ou List.:::() método ou List.concat()método para adicionar duas ou mais listas. Encontre o seguinte exemplo fornecido abaixo -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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)

Criação de listas uniformes

Você pode usar List.fill()método cria uma lista que consiste em zero ou mais cópias do mesmo elemento. Experimente o seguinte programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Tabulando uma função

Você pode usar uma função junto com List.tabulate()método para aplicar em todos os elementos da lista antes de tabular a lista. Seus argumentos são como os de List.fill: a primeira lista de argumentos fornece as dimensões da lista a ser criada e a segunda descreve os elementos da lista. A única diferença é que em vez de os elementos serem fixos, eles são calculados a partir de uma função.

Experimente o seguinte programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Ordem reversa da lista

Você pode usar List.reversemétodo para reverter todos os elementos da lista. O exemplo a seguir mostra o uso.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala fornece uma estrutura de dados, o ListBuffer, que é mais eficiente do que List ao adicionar / remover elementos em uma lista. Ele fornece métodos para preceder, acrescentar elementos a uma lista.

Declarando Variáveis ListBuffer

A seguir está a sintaxe para declarar uma variável ListBuffer.

Sintaxe

var z = ListBuffer[String]()

Aqui, z é declarado como um buffer de lista de Strings que está inicialmente vazio. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando ListBuffer

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar ListBuffer -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Set é uma coleção de elementos diferentes em pares do mesmo tipo. Em outras palavras, um conjunto é uma coleção que não contém elementos duplicados. ListSet implementa conjuntos imutáveis e usa estrutura de lista. A ordem de inserção dos elementos é preservada durante o armazenamento dos elementos.

Declaração de variáveis ListSet

A seguir está a sintaxe para declarar uma variável ListSet.

Sintaxe

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

Aqui, z é declarado como um conjunto de listas de Strings que possui três membros. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando ListSet

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar ListSet -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Vector é uma estrutura de dados imutável de propósito geral onde os elementos podem ser acessados aleatoriamente. Geralmente é usado para grandes coleções de dados.

Declaração de variáveis vetoriais

A seguir está a sintaxe para declarar uma variável Vector.

Sintaxe

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

Aqui, z é declarado como um vetor de Strings que possui três membros. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando Vetor

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar Vector -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Set é uma coleção de elementos diferentes em pares do mesmo tipo. Em outras palavras, um conjunto é uma coleção que não contém elementos duplicados. Existem dois tipos de conjuntos, oimmutable e a mutable. A diferença entre objetos mutáveis e imutáveis é que quando um objeto é imutável, o próprio objeto não pode ser alterado.

Por padrão, Scala usa o Conjunto imutável. Se você quiser usar o conjunto mutável, você terá que importarscala.collection.mutable.Setclasse explicitamente. Se você deseja usar conjuntos mutáveis e imutáveis na mesma coleção, pode continuar a referir-se ao conjunto imutável comoSet mas você pode se referir ao conjunto mutável como mutable.Set.

Aqui está como você pode declarar conjuntos imutáveis -

Sintaxe

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

Ao definir um conjunto vazio, a anotação de tipo é necessária, pois o sistema precisa atribuir um tipo concreto à variável.

Operações básicas no set

Todas as operações em conjuntos podem ser expressas em termos dos seguintes três métodos -

Sr. Não	Métodos e Descrição
1	head Este método retorna o primeiro elemento de um conjunto.
2	tail Este método retorna um conjunto que consiste em todos os elementos, exceto o primeiro.
3	isEmpty Este método retorna verdadeiro se o conjunto estiver vazio, caso contrário, é falso.

Experimente o exemplo a seguir, mostrando o uso dos métodos operacionais básicos -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Conjuntos de concatenação

Você pode usar qualquer ++ operador ou Set.++() método para concatenar dois ou mais conjuntos, mas ao adicionar conjuntos removerá elementos duplicados.

A seguir está o exemplo para concatenar dois conjuntos.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Encontre o máximo e o mínimo de elementos em um conjunto

Você pode usar Set.min método para descobrir o mínimo e Set.maxmétodo para descobrir o máximo de elementos disponíveis em um conjunto. A seguir está o exemplo para mostrar o programa.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Encontre inserções de valores comuns

Você pode usar qualquer Set.& método ou Set.intersectmétodo para descobrir os valores comuns entre dois conjuntos. Experimente o seguinte exemplo para mostrar o uso.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Bitset é uma classe base comum para bitsets mutáveis e imutáveis. Os conjuntos de bits são conjuntos de inteiros não negativos e são representados como matrizes de tamanho variável de bits compactados em palavras de 64 bits. A área de cobertura da memória de um bitset é representada pelo maior número armazenado nele.

Declarando Variáveis BitSet

A seguir está a sintaxe para declarar uma variável BitSet.

Sintaxe

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

Aqui, z é declarado como um conjunto de bits de inteiros não negativos que possui três membros. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

var myList1: BitSet = myList + 3;

Processando BitSet

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar BitSet -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Set é uma coleção de elementos diferentes em pares do mesmo tipo. Em outras palavras, um conjunto é uma coleção que não contém elementos duplicados. HashSet implementa conjuntos imutáveis e usa tabela de hash. A ordem de inserção dos elementos não é preservada.

Declarando Variáveis HashSet

A seguir está a sintaxe para declarar uma variável HashSet.

Sintaxe

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

Aqui, z é declarado como um conjunto hash de Strings que possui três membros. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando HashSet

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar HashSet -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Set é uma coleção de elementos diferentes em pares do mesmo tipo. Em outras palavras, um conjunto é uma coleção que não contém elementos duplicados. TreeSet implementa conjuntos imutáveis e mantém os elementos em ordem classificada.

Declarando Variáveis TreeSet

A seguir está a sintaxe para declarar uma variável TreeSet.

Sintaxe

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

Aqui, z é declarado como um conjunto em árvore de Strings que possui três membros. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando TreeSet

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar TreeSet -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O mapa Scala é uma coleção de pares de chave / valor. Qualquer valor pode ser recuperado com base em sua chave. As chaves são exclusivas no mapa, mas os valores não precisam ser exclusivos. Os mapas também são chamados de tabelas Hash. Existem dois tipos de mapas, oimmutable e a mutable. A diferença entre objetos mutáveis e imutáveis é que quando um objeto é imutável, o próprio objeto não pode ser alterado.

Por padrão, Scala usa o mapa imutável. Se você quiser usar o mapa mutável, você terá que importarscala.collection.mutable.Mapclasse explicitamente. Se você deseja usar mapas mutáveis e imutáveis no mesmo, então você pode continuar a se referir ao mapa imutável comoMap mas você pode se referir ao conjunto mutável como mutable.Map.

A seguir estão as instruções de exemplo para declarar mapas imutáveis -

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

Ao definir o mapa vazio, a anotação de tipo é necessária, pois o sistema precisa atribuir um tipo concreto à variável. Se quisermos adicionar um par de valores-chave a um Mapa, podemos usar o operador + como segue.

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

Operações básicas no MAP

Todas as operações em mapas podem ser expressas em termos dos três métodos a seguir.

Sr. Não	Métodos e Descrição
1	keys Este método retorna um iterável contendo cada chave no mapa.
2	values Este método retorna um iterável contendo cada valor no mapa.
3	isEmpty Este método retorna verdadeiro se o mapa estiver vazio, caso contrário, é falso.

Experimente o programa de exemplo a seguir, mostrando o uso dos métodos Map.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Mapas de Concatenação

Você pode usar qualquer ++ operador ou Map.++() método para concatenar dois ou mais mapas, mas ao adicionar mapas removerá chaves duplicadas.

Experimente o programa de exemplo a seguir para concatenar dois mapas.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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)

Imprimir chaves e valores de um mapa

Você pode iterar pelas chaves e valores de um mapa usando o loop "foreach". Aqui, usamos o métodoforeachassociado ao iterador para percorrer as chaves. A seguir está o programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Verifique se há uma chave no mapa

Você pode usar qualquer Map.containsmétodo para testar se uma determinada chave existe ou não no mapa. Experimente o programa de exemplo a seguir para verificação de chave.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Declarando Variáveis HashMap

A seguir está a sintaxe para declarar uma variável HashMap.

Sintaxe

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

Aqui, as cores são declaradas como um mapa hash de Strings, Int, que tem três pares de valores-chave. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando HashMap

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar HashMap -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O mapa Scala é uma coleção de pares de chave / valor. Qualquer valor pode ser recuperado com base em sua chave. As chaves são exclusivas no mapa, mas os valores não precisam ser exclusivos. ListMap implementa mapa imutável e usa lista para implementar o mesmo. É usado com pequeno número de elementos.

Declarando Variáveis ListMap

A seguir está a sintaxe para declarar uma variável ListMap.

Sintaxe

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

Aqui, as cores são declaradas como um mapa hash de Strings, Int, que tem três pares de valores-chave. Os valores podem ser adicionados usando comandos como os seguintes -

Comando

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

Processando ListMap

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar ListMap -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Um iterador não é uma coleção, mas sim uma maneira de acessar os elementos de uma coleção um por um. As duas operações básicas em umiterator it está next e hasNext. Uma chamada parait.next()retornará o próximo elemento do iterador e avançará o estado do iterador. Você pode descobrir se há mais elementos para retornar usando o Iteratorit.hasNext método.

A maneira mais direta de "percorrer" todos os elementos retornados por um iterador é usar um loop while. Vamos seguir o seguinte programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

a
number
of
words

Encontre o elemento de valor mínimo e máximo

Você pode usar it.min e it.maxmétodos para descobrir os elementos de valor mínimo e máximo de um iterador. Aqui, usamosita e itbpara executar duas operações diferentes porque o iterador pode ser percorrido apenas uma vez. A seguir está o programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Maximum valued element 90
Minimum valued element 2

Encontre o comprimento do iterador

Você pode usar qualquer it.size ou it.lengthmétodos para descobrir o número de elementos disponíveis em um iterador. Aqui, usamos ita e itb para realizar duas operações diferentes porque o iterador pode ser percorrido apenas uma vez. A seguir está o programa de exemplo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Option [T] é um contêiner para zero ou um elemento de um determinado tipo. Uma opção [T] pode serSome[T] ou Noneobjeto, que representa um valor ausente. Por exemplo, o método get do Mapa de Scala produz Some (valor) se um valor correspondente a uma determinada chave for encontrado, ouNone se a chave fornecida não estiver definida no mapa.

O tipo de opção é usado freqüentemente em programas Scala e você pode comparar isso com o nullvalor disponível em Java que não indica nenhum valor. Por exemplo, o método get de java.util.HashMap retorna um valor armazenado no HashMap ou nulo se nenhum valor foi encontrado.

Digamos que temos um método que recupera um registro do banco de dados com base em uma chave primária.

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

O método retornará Some [Person] se o registro for encontrado, mas None se o registro não for encontrado. Vamos seguir o seguinte programa.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

A maneira mais comum de separar valores opcionais é por meio de uma correspondência de padrão. Por exemplo, tente o seguinte programa.

Exemplo

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 => "?"
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Usando o método getOrElse ()

A seguir está o programa de exemplo para mostrar como usar o método getOrElse () para acessar um valor ou um padrão quando nenhum valor está presente.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Usando o método isEmpty ()

A seguir está o programa de exemplo para mostrar como usar o método isEmpty () para verificar se a opção é None ou não.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Exemplo

a.isEmpty: false
b.isEmpty: true

A fila é o primeiro a entrar, primeiro a sair, estrutura de dados FIFO e permite inserir e recuperar elementos no modo FIFO.

Declaração de variáveis de fila

A seguir está a sintaxe para declarar uma variável Queue.

Sintaxe

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

Aqui, a fila é declarada como uma fila de números. O valor pode ser adicionado na frente usando comandos como o seguinte -

Comando

queue.enqueue(6)

O valor pode ser recuperado na frente usando comandos como o seguinte -

Comando

queue.dequeue()

Fila de Processamento

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar a fila -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

A tupla do Scala combina um número fixo de itens para que possam ser passados como um todo. Ao contrário de uma matriz ou lista, uma tupla pode conter objetos com diferentes tipos, mas também são imutáveis.

A seguir está um exemplo de uma tupla contendo um inteiro, uma string e o console.

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

Qual é o açúcar sintático (atalho) para o seguinte -

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

O tipo real de uma tupla depende do número e dos elementos que ela contém e dos tipos desses elementos. Assim, o tipo de (99, "Luftballons") é Tuple2 [Int, String]. O tipo de ('u', 'r', "o", 1, 4, "eu") é Tupla6 [Car, Car, String, Int, Int, String]

As tuplas são do tipo Tupla1, Tupla2, Tupla3 e assim por diante. Atualmente, há um limite máximo de 22 no Scala, se você precisar de mais, então pode usar uma coleção, não uma tupla. Para cada tipo TupleN, onde 1 <= N <= 22, Scala define vários métodos de acesso a elementos. Dada a seguinte definição -

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

Para acessar os elementos de uma tupla t, você pode usar o método t._1 para acessar o primeiro elemento, t._2 para acessar o segundo e assim por diante. Por exemplo, a seguinte expressão calcula a soma de todos os elementos de t.

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

Você pode usar Tupla para escrever um método que recebe uma Lista [Duplo] e retorna a contagem, a soma e a soma dos quadrados retornados em uma Tupla de três elementos, uma Tupla3 [Int, Duplo, Duplo]. Eles também são úteis para passar uma lista de valores de dados como mensagens entre atores na programação simultânea.

Experimente o seguinte programa de exemplo. Mostra como usar uma tupla.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comandos

\>scalac Demo.scala
\>scala Demo

Resultado

Sum of elements: 10

Iterar sobre a tupla

Você pode usar Tuple.productIterator() método para iterar sobre todos os elementos de uma tupla.

Experimente o programa de exemplo a seguir para iterar nas tuplas.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comandos

\>scalac Demo.scala
\>scala Demo

Resultado

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

Convertendo para String

Você pode usar Tuple.toString()método para concatenar todos os elementos da tupla em uma string. Experimente o programa de exemplo a seguir para converter em String.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Troque os elementos

Você pode usar Tuple.swap método para trocar os elementos de um Tuple2.

Experimente o programa de exemplo a seguir para trocar os elementos.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Swapped tuple: (hello,Scala)

Scala Seq é um traço para representar sequências imutáveis. Essa estrutura fornece acesso baseado em índice e vários métodos utilitários para localizar elementos, suas ocorrências e subsequências. Um Seq mantém o pedido de inserção.

Declarando Variáveis Seq

A seguir está a sintaxe para declarar uma variável Seq.

Sintaxe

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

Aqui, seq é declarado como um Seq de números. Seq fornece comandos como o seguinte -

Comando

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

Processando Seq

Abaixo está um exemplo de programa mostrando como criar, inicializar e processar Seq -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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 é o último a entrar, primeiro a sair, estrutura de dados LIFO e permite inserir e recuperar o elemento no topo, de maneira LIFO.

Declaração de variáveis de pilha

A seguir está a sintaxe para declarar uma variável Stack.

Sintaxe

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

Aqui, a pilha é declarada como uma pilha de números. O valor pode ser adicionado no topo usando comandos como os seguintes -

Comando

stack.push(6)

O valor pode ser recuperado de cima usando comandos como o seguinte -

Comando

stack.top

O valor pode ser removido do topo usando comandos como o seguinte -

Comando

stack.pop

Pilha de Processamento

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar Stack -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Scala Stream é uma lista especial com recurso de avaliação lenta. No fluxo do scala, os elementos são avaliados apenas quando são necessários. O Stream oferece suporte à computação lenta e ao desempenho.

Declaração de variáveis de fluxo

A seguir está a sintaxe para declarar uma variável Stream.

Sintaxe

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

Aqui, stream é declarado como um stream de números. Aqui, 1 é a cauda do rio, 2, 3 são a cauda do rio. Stream.empty marca o fim do fluxo. Os valores podem ser recuperados usando comandos take como os seguintes -

Comando

stream.take(2)

Stream de processamento

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar Stream -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O método drop () é o método usado por List para selecionar todos os elementos, exceto os primeiros n elementos da lista.

Sintaxe

A seguir está a sintaxe do método drop.

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

Aqui, n é o número de elementos a serem eliminados da lista. Este método retorna todos os elementos da lista, exceto os primeiros n.

Uso

Abaixo está um exemplo de programa mostrando como usar o método drop -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O método dropWhile () é usado por List para eliminar todos os elementos que satisfaçam uma determinada condição.

Sintaxe

A seguir está a sintaxe do método dropWhile.

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

Aqui, p: (A) => Booleano é um predicado ou condição a ser aplicada em cada elemento da lista. Este método retorna todos os elementos da lista, exceto os eliminados.

Uso

Abaixo está um programa de exemplo mostrando como usar o método dropWhile -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O método filter () é usado por List para selecionar todos os elementos que satisfaçam um determinado predicado.

Sintaxe

A seguir está a sintaxe do método de filtro.

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

Aqui, p: (A) => Booleano é um predicado ou condição a ser aplicada em cada elemento da lista. Este método retorna todos os elementos da lista que satisfazem a condição dada.

Uso

Abaixo está um programa de exemplo mostrando como usar o método de filtro -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O método find () é o método usado pelos Iteradores para encontrar um elemento que satisfaça um determinado predicado.

Sintaxe

A seguir está a sintaxe do método find.

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

Aqui, p: (A) => Boolean é um predicado ou condição a ser aplicado em cada elemento do iterador. Este método retorna o elemento Option contendo o elemento correspondente do iterador que satisfaz a condição fornecida.

Uso

Abaixo está um programa de exemplo mostrando como usar o método de localização -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Some(3)

O método flatMap () é o método do traço TraversableLike, ele pega um predicado, aplica-o a cada elemento da coleção e retorna uma nova coleção de elementos retornados pelo predicado.

Sintaxe

A seguir está a sintaxe do método flatMap.

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

Aqui, f: (A)? GenTraversableOnce [B] é um predicado ou condição a ser aplicada em cada elemento da coleção. Este método retorna o elemento Option contendo o elemento correspondente do iterador que satisfaz a condição fornecida.

Uso

Abaixo está um exemplo de programa mostrando como usar o método flatMap -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

O método flatten () é um membro GenericTraversableTemplate traço, ele retorna uma única coleção de elementos mesclando coleções filho.

Sintaxe

A seguir está a sintaxe do método flatten.

def flatten[B]: Traversable[B]

Uso

Abaixo está um programa de exemplo mostrando como usar o método nivelar -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

List(1, 2, 3, 4)

O método fold () é um membro do traço TraversableOnce, é usado para recolher elementos de coleções.

Sintaxe

A seguir está a sintaxe do método fold.

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

Aqui, o método fold leva a função do operador binário associativo como parâmetro. Este método retorna o resultado como valor. Ele considera a primeira entrada como valor inicial e a segunda entrada como uma função (que leva o valor acumulado e o item atual como entrada).

Uso

Abaixo está um exemplo de programa mostrando como usar o método de dobra -

Exemplo

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

Aqui, passamos 0 como valor inicial para a função de dobra e, em seguida, todos os valores são adicionados. Salve o programa acima emDemo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

O método foldLeft () é um membro do traço TraversableOnce, é usado para recolher elementos de coleções. Ele navega pelos elementos da ordem da esquerda para a direita. É usado principalmente em funções recursivas e evita exceções de estouro de pilha.

Sintaxe

A seguir está a sintaxe do método fold.

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

Aqui, o método foldLeft usa a função de operador binário associativo como parâmetro. Este método retorna o resultado como valor.

Uso

Abaixo está um programa de exemplo mostrando como usar o método foldLeft -

Exemplo

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

Resultado

O método foldRight () é um membro do traço TraversableOnce, é usado para recolher elementos de coleções. Ele navega pelos elementos da ordem da direita para a esquerda.

Sintaxe

A seguir está a sintaxe do método foldRight.

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

Aqui, o método fold leva a função do operador binário associativo como parâmetro. Este método retorna o valor resultante.

Uso

Abaixo está um exemplo de programa mostrando como usar o método foldRight -

Exemplo

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

Aqui, passamos 0 como valor inicial para a função foldRight e todos os valores são adicionados. Salve o programa acima emDemo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

O método map () é um membro do traço TraversableLike, é usado para executar um método de predicado em cada elemento de uma coleção. Ele retorna uma nova coleção.

Sintaxe

A seguir está a sintaxe do método map.

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

Aqui, o método do mapa usa uma função pré-mediada como parâmetro. Este método retorna a coleção atualizada.

Uso

Abaixo está um exemplo de programa mostrando como usar o método de mapa -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

List(2, 4, 6, 8)

O método partition () é um membro do traço TraversableLike, ele é usado para executar um método predicado em cada elemento de uma coleção. Ele retorna duas coleções, uma coleção é de elementos que satisfazem uma determinada função de predicado e outra coleção é de elementos que não satisfazem a função de predicado fornecida.

Sintaxe

A seguir está a sintaxe do método map.

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

Here, partition method takes a prediate function as a parameter. This method returns the collections.

Usage

Below is an example program of showing how to use partition method −

Example

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

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

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

reduce() method is a member of TraversableOnce trait, it is used to collapse elements of collections. It is similar to fold method but it does not take initial value.

Syntax

The following is the syntax of reduce method.

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

Here, reduce method takes associative binary operator function as a parameter. This method returns the resultant value.

Usage

Below is an example program of showing how to use fold method −

Example

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

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

scan() method is a member of TraversableLike trait, it is similar to fold method but is used to apply a operation on each elements of collection and return a collection.

Syntax

The following is the syntax of fold method.

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

Here, scan method takes associative binary operator function as a parameter. This method returns the updated collection as result. It considers first input as initial value and second input as a function.

Usage

Below is an example program of showing how to use scan method −

Example

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

Here we've passed 0 as initial value to scan function and then all values are added. Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

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

zip() method is a member of IterableLike trait, it is used to merge a collection to current collection and result is a collection of pair of tuple elements from both collections.

Syntax

The following is the syntax of zip method.

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

Here, zip method takes a collection as parameter. This method returns the updated collection of pair as result.

Usage

Below is an example program of showing how to use zip method −

Example

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

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

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

Coleções Scala - Guia rápido

Etapa 1: verifique sua instalação Java

Etapa 2: definir seu ambiente Java

Etapa 3: Instale o Scala

Declarando Variáveis ​​de Matriz

Sintaxe

Comando

Processando matrizes

Exemplo

Comando

Resultado

Exemplo

Comando

Resultado

Exemplo

Comando

Resultado

Declarando Variáveis ​​ArrayBuffer

Sintaxe

Comando

Processando ArrayBuffer

Exemplo

Comando

Resultado

Operações básicas em listas

Exemplo

Comando

Resultado

Listas de concatenação

Exemplo

Comando

Resultado

Criação de listas uniformes

Exemplo

Comando

Resultado

Tabulando uma função

Exemplo

Comando

Resultado

Ordem reversa da lista

Exemplo

Comando

Resultado

Declarando Variáveis ​​ListBuffer

Sintaxe

Comando

Processando ListBuffer

Exemplo

Comando

Resultado

Declaração de variáveis ​​ListSet

Sintaxe

Comando

Processando ListSet

Exemplo

Comando

Resultado

Declaração de variáveis ​​vetoriais

Sintaxe

Comando

Processando Vetor

Exemplo

Comando

Resultado

Sintaxe

Operações básicas no set

Exemplo

Comando

Resultado

Conjuntos de concatenação

Exemplo

Comando

Resultado

Encontre o máximo e o mínimo de elementos em um conjunto

Exemplo

Comando

Resultado

Encontre inserções de valores comuns

Exemplo

Declarando Variáveis de Matriz

Declarando Variáveis ArrayBuffer

Declarando Variáveis ListBuffer

Declaração de variáveis ListSet

Declaração de variáveis vetoriais

Declarando Variáveis BitSet

Declarando Variáveis HashSet

Declarando Variáveis TreeSet

Declarando Variáveis HashMap

Declarando Variáveis ListMap