Listas en Scala

Puede que también te interesen estos tutoriales:

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

Introducción

Estructura de lista simplemente enlazada que implementa una lista con 3 elementos enteros (fuente: Wikipedia - List (abstract data type)).

En general, una lista es una secuencia de tipos de datos abstractos que representa un número fijo de valores. Esos valores pueden manipularse mediante un programa y también pueden repetirse dentro de la lista. Un ejemplo de instancia de lista aparece en la figura superior como una lista simplemente enlazada formada por tres enteros. La lista también se considera una estructura de datos; un ejemplo típico son las listas enlazadas.

Muchos lenguajes de programación incorporan listas; un caso muy extendido es Python. A menudo, una lista se construye escribiendo los elementos en secuencia, separados por comas, puntos y coma o espacios, dentro de un par de delimitadores como paréntesis (), corchetes [], llaves {} o ángulos <>. Algunos lenguajes como Python permiten indexar o segmentar (slice) las listas como si fueran arrays; en ese caso, el tipo de datos se describe con más precisión como un array (fuente: Wikipedia - List (abstract data type)).

En Scala, una lista es una colección que contiene datos inmutables; es decir, una vez creada, no se puede modificar. En Scala, la lista representa una lista enlazada.

En una lista de Scala, cada elemento no tiene por qué ser del mismo tipo de datos. La implementación de las listas en Scala utiliza estado mutable internamente durante la fase de construcción. En Scala, las listas están definidas en el paquete scala.collection.immutable y, por tanto, son inmutables. Por último, una lista de Scala ofrece varios métodos como add, prepend, max, min, etc.

Sintaxis para definir una lista en Scala

val variable_name: List[type] = List(item1, item2, item3) o val variable_name = List(item1, item2, item3) Una lista en Scala se parece mucho a un array de Scala. Sin embargo, la lista en Scala es inmutable y representa una estructura de datos de lista enlazada. En cambio, el array en Scala es plano y mutable.

Veamos rápidamente esta diferencia con un ejemplo.

Scala List vs. Scala Array

Primero definamos un array en Scala.

Después, modifica el valor en el índice 1 (recuerda que los arrays en Scala empiezan en 0) y comprueba si puedes actualizarlo.

Como ves en el fragmento anterior, el array de Scala te permitió modificar el valor en el índice 1.

Ahora define una Scala List e intenta hacer lo mismo.

Bien, a partir del ejemplo anterior puedes concluir que, como las listas de Scala son inmutables, al intentar actualizar el valor se produce un error.

Métodos de Scala List

• head: devuelve el primer elemento de la lista.

• tail: devuelve todos los elementos excepto el primero.

• isEmpty: comprueba si la lista está vacía; en ese caso devuelve True, si no, False.

• fill(): crea una lista uniforme con cero o más copias del elemento indicado.

• reverse: invierte el orden de los elementos de la lista.

• $:::$ o $.:::$ o .concat(): concatena dos o más listas.

• tabulate(): tabula una lista. Es similar en espíritu a fill(), pero a diferencia de fill(), recibe dos argumentos. El primero indica las dimensiones de la lista que se va a crear y el segundo describe los elementos de la lista, que se calculan a partir de una función.

No te preocupes si alguno de estos métodos no te resulta del todo claro: los implementarás en Scala con un ejemplo. Pero antes, aprendamos a definir listas en Scala.

Vas a crear listas en Scala con tipos de datos string e integer (tanto 1D como 2D). También verás cómo crear una lista que combine cadenas y enteros.

Lista de enteros 1D

Lista 1D con enteros y cadenas

Lista de cadenas 1D

Lista 2D

Operaciones aritméticas con listas

En este ejemplo, usarás listas en lugar de simples variables. A diferencia de una variable, una lista puede contener n valores; realizarás operaciones aritméticas sobre dos listas en lugar de sobre dos variables.

Veamos rápidamente cómo hacerlo.

Para aplicar las operaciones, utilizarás la función zipped.map seguida de las listas x e y. Luego indicarás en el método zipped.map la operación que quieres realizar como argumento.

Por último, escribamos un código que reúna todos estos 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)));
}
}

Conclusión

Enhorabuena por completar este tutorial de Scala.

No dudes en dejar tus preguntas sobre este tutorial en los comentarios de abajo.