Colecciones Scala - Lista

Las listas Scala son bastante similares a las matrices, lo que significa que todos los elementos de una lista tienen el mismo tipo, pero hay dos diferencias importantes. Primero, las listas son inmutables, lo que significa que los elementos de una lista no se pueden cambiar por asignación. En segundo lugar, las listas representan una lista vinculada, mientras que las matrices son planas.

El tipo de lista que tiene elementos de tipo T se escribe como List[T].

Pruebe el siguiente ejemplo, aquí hay algunas listas definidas para varios tipos de datos.

// 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 las listas se pueden definir utilizando dos bloques de construcción fundamentales, una cola Nil y ::, que se pronuncia cons. Nil también representa la lista vacía. Todas las listas anteriores se pueden definir de la siguiente manera.

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

Operaciones básicas en listas

Todas las operaciones en listas se pueden expresar en términos de los siguientes tres métodos.

No Señor	Métodos y descripción
1	head Este método devuelve el primer elemento de una lista.
2	tail Este método devuelve una lista que consta de todos los elementos excepto el primero.
3	isEmpty Este método devuelve verdadero si la lista está vacía; de lo contrario, es falso.

El siguiente ejemplo muestra cómo utilizar los métodos anteriores.

Ejemplo

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

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

\>scalac Demo.scala
\>scala Demo

Salida

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

Listas de concatenación

Puedes usar cualquiera ::: operador o List.:::() método o List.concat()método para agregar dos o más listas. Encuentre el siguiente ejemplo que se muestra a continuación:

Ejemplo

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

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

\>scalac Demo.scala
\>scala Demo

Salida

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)

Crear listas uniformes

Puedes usar List.fill()El método crea una lista que consta de cero o más copias del mismo elemento. Pruebe el siguiente programa de ejemplo.

Ejemplo

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

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

\>scalac Demo.scala
\>scala Demo

Salida

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

Tabulación de una función

Puede utilizar una función junto con List.tabulate()método para aplicar en todos los elementos de la lista antes de tabular la lista. Sus argumentos son como los de List.fill: la primera lista de argumentos da las dimensiones de la lista a crear, y la segunda describe los elementos de la lista. La única diferencia es que en lugar de que los elementos sean fijos, se calculan a partir de una función.

Pruebe el siguiente programa de ejemplo.

Ejemplo

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

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

\>scalac Demo.scala
\>scala Demo

Salida

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

Orden de lista inverso

Puedes usar List.reversemétodo para invertir todos los elementos de la lista. El siguiente ejemplo muestra el uso.

Ejemplo

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

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

\>scalac Demo.scala
\>scala Demo

Salida

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