Scala List (Lista)

def +:(elem: A): List[A]

Agrega un elemento al principio de la lista

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

def ::(x: A): List[A]

Agrega un elemento al comienzo de la lista

def :::(prefix: List[A]): List[A]

Agrega los elementos de la lista especificada al comienzo de la lista

def :+(elem: A): List[A]

Devuelve una copia de la lista con el elemento añadido

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

def addString(b: StringBuilder): StringBuilder

Agrega todos los elementos de la lista a StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

Agrega todos los elementos de la lista a StringBuilder, especificando el separador

def apply(n: Int): A

Obtiene el elemento mediante el índice de la lista

def contains(elem: Any): Boolean

Comprueba si la lista contiene el elemento especificado

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

Copia los elementos de la lista a un array

def distinct: List[A]

Elimina los elementos duplicados de la lista y devuelve una nueva lista

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

Descarta los primeros n elementos y devuelve una nueva lista

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

Descarta los últimos n elementos y devuelve una nueva lista

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

Descarta elementos de izquierda a derecha hasta que la condición p no se cumpla

def endsWith[B](that: Seq[B]): Boolean

Comprueba si la lista termina con la secuencia especificada

def equals(that: Any): Boolean

Determina si son iguales

def exists(p: (A) => Boolean): Boolean

Comprueba si existe algún elemento en la lista que cumpla la condición especificada

Comprueba si existe algún elemento en l:

scala> l.exists(s => s == "Hah")
res7: Boolean = true

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

Devuelve todos los elementos que cumplen la condición especificada

Filtra los elementos de longitud 3:

scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)

def forall(p: (A) => Boolean): Boolean

Comprueba todos los elementos

Por ejemplo: comprobar si todos los elementos comienzan con "H":

def foreach(f: (A) => Unit): Unit

Aplica la función a todos los elementos de la lista

def head: A

Obtiene el primer elemento de la lista

def indexOf(elem: A, from: Int): Int

Desde la posición especificada from, busca la primera aparición del elemento

def init: List[A]

Devuelve todos los elementos excepto el último

def intersect(that: Seq[A]): List[A]

Calcula la intersección de varias colecciones

def isEmpty: Boolean

Comprueba si la lista está vacía

def iterator: Iterator[A]

Crea un nuevo iterador para iterar sobre los elementos

def last: A

Devuelve el último elemento

def lastIndexOf(elem: A, end: Int): Int

Busca la última aparición del elemento comenzando en la posición especificada end

def length: Int

Devuelve la longitud de la lista

def map[B](f: (A) => B): List[B]

Recalcula todos los elementos mediante el método dado

def max: A

Busca el elemento máximo

def min: A

Busca el elemento mínimo

def mkString: String

Muestra todos los elementos de la lista como una cadena

def mkString(sep: String): String

Muestra todos los elementos de la lista como una cadena utilizando un separador

def reverse: List[A]

Invierte la lista

def sorted[B >: A]: List[A]

Ordena la lista

def startsWith[B](that: Seq[B], offset: Int): Boolean

Comprueba si la lista contiene la secuencia especificada en la posición especificada

def sum: A

Calcula la suma de los elementos de la colección

def tail: List[A]

Devuelve todos los elementos excepto el primero

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

Extrae los primeros n elementos de la lista

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

Extrae los últimos n elementos de la lista

def toArray: Array[A]

Convierte la lista en un array

def toBuffer[B >: A]: Buffer[B]

Devuelve un buffer que contiene todos los elementos de la lista

def toMap[T, U]: Map[T, U]

Convierte List en Map

def toSeq: Seq[A]

Convierte List en Seq

def toSet[B >: A]: Set[B]

Convierte List en Set

def toString(): String

Convierte la lista en una cadena