Listas em Scala

Você também pode se interessar pelos tutoriais abaixo:

• Beginners Guide to Scala
• IF ELSE in Scala
• Operators in Scala

Introdução

Uma estrutura de lista simplesmente encadeada, implementando uma lista com 3 elementos inteiros (Fonte: Wikipedia - List (abstract data type)).

De forma geral, uma lista é uma sequência de tipos de dados abstratos que representa uma quantidade fixa de valores. Esses valores podem ser manipulados por um programa e também podem aparecer mais de uma vez na mesma lista. Um exemplo de instância de lista é mostrado na figura acima, como uma lista simplesmente encadeada com três valores inteiros. A lista também é considerada uma estrutura de dados, e um exemplo clássico é a lista encadeada (linked list).

Muitas linguagens de programação oferecem suporte a listas, e um exemplo em que elas são muito usadas é o Python. Normalmente, você pode construir uma lista escrevendo os itens em sequência, separados por vírgulas, ponto e vírgula ou espaços, entre delimitadores como parênteses (), colchetes [], chaves {} ou sinais de menor/maior <>. Algumas linguagens, como Python, permitem indexar ou fatiar listas como arrays; nesse caso, o tipo de dado é mais precisamente descrito como um array (Fonte: Wikipedia - List (abstract data type)).

Específico para Scala, uma lista é uma coleção que contém dados imutáveis, ou seja, depois de criada, ela não pode ser alterada. Em Scala, a lista representa uma linked list.

Em uma lista Scala, cada elemento não precisa ter o mesmo tipo de dado. A implementação de listas em Scala usa estado mutável internamente durante a fase de construção. Em Scala, a lista é definida no pacote scala.collection.immutable e, portanto, é imutável. Por fim, uma Scala List oferece vários métodos como add, prepend, max, min, entre outros.

Sintaxe para definir uma Scala List

val variable_name: List[type] = List(item1, item2, item3) ou val variable_name = List(item1, item2, item3). Uma lista em Scala é muito parecida com um array em Scala. Porém, a Scala List é imutável e representa uma estrutura de dados do tipo linked list. Já o array em Scala é linear (flat) e mutável.

Vamos entender rapidamente essa diferença com um exemplo.

Scala List vs. Scala Array

Primeiro, vamos definir um array em Scala.

Em seguida, você vai modificar o valor no índice 1 (arrays em Scala começam no zero) para ver se a atualização é possível.

Como dá para ver pelo trecho de código acima, o array em Scala permitiu alterar o valor no índice 1.

Agora, vamos definir uma Scala List e tentar fazer o mesmo.

Pelo exemplo acima, dá para concluir que, como as Scala Lists são imutáveis, tentar atualizar o valor resultou em erro.

Métodos de Scala List

• head: retorna o primeiro elemento da lista.

• tail: retorna todos os elementos, exceto o primeiro.

• isEmpty: verifica se a lista está vazia; retorna True se estiver, caso contrário False.

• fill(): cria uma lista uniforme com zero ou mais cópias do elemento especificado.

• reverse: inverte a ordem dos elementos da lista.

• $:::$ ou $.:::$ ou .concat(): concatena duas ou mais listas.

• tabulate(): permite tabular uma lista. É semelhante ao método fill(), mas, ao contrário dele, recebe dois argumentos. O primeiro informa as dimensões da lista a ser criada, enquanto o segundo descreve os elementos da lista, calculados a partir de uma função.

Não se preocupe se alguns métodos acima ainda não fizerem muito sentido. Você vai implementá-los em Scala com um exemplo. Antes disso, vamos aprender a definir listas em Scala.

Você vai criar Scala Lists com tipos string e inteiro (1D e 2D). Também vai aprender a criar uma lista que mistura strings e inteiros.

Lista de inteiros 1D

Lista 1D com inteiros e strings

Lista de strings 1D

Lista 2D

Operações aritméticas em listas

Neste exemplo, em vez de definir apenas variáveis, você vai usar listas. Diferente de uma variável, uma lista pode guardar n valores; então, vamos executar operações aritméticas em duas listas, e não em duas variáveis.

Vamos ver rapidamente como fazer isso.

Para aplicar as operações aritméticas, vamos usar a função zipped.map seguida das listas x e y. Depois, você especifica na chamada de zipped.map a operação que deseja executar como argumento.

Por fim, vamos escrever um código que reúne todos esses métodos.

object Scala_List_Methods
{

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

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

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

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

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

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

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

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

Conclusão

Parabéns por concluir este tutorial de Scala.

Se tiver qualquer dúvida sobre este tutorial, fique à vontade para perguntar na seção de comentários abaixo.