empty - scala listbuffer add

Agregar elemento a una lista en Scala

Question

Estoy ejecutando Scala 2.10.2. Quiero crear una lista, luego agregar algunos elementos a la lista y esperar ver todos los elementos en las listas cuando llamo al nombre de la lista. Pero observé algo bastante raro (al menos extraño para mí ya que soy novato). A continuación se muestra lo que traté de hacer en mi sbt console

scala> val l = 1.0 :: 5.5 :: Nil
l: List[Double] = List(1.0, 5.5)
scala> l
res0: List[Double] = List(1.0, 5.5)
scala> l ::: List(2.2, 3.7)
res1: List[Double] = List(1.0, 5.5, 2.2, 3.7)
scala> List(l) :+ 2.2
res2: List[Any] = List(List(1.0, 5.5), 2.2)
scala> l
res3: List[Double] = List(1.0, 5.5)
scala>

Primero, creé la lista l con 2 elementos (1.0 y 5.5). Llamé a l y obtuve lo que esperaba; los dos elementos. Ahora traté de agregar otro elemento a la lista usando ::: que me devolvió una nueva lista con una nueva lista de elementos que agregué (2.2 y 3.7) ¡Dulce! Incluso revisé el código de otra persona en busca de ayuda: agregar un elemento al final de una lista en Scala para usar una construcción nueva :+ . Así que en esta etapa estoy contento, pero llamo a l y obtengo lo inesperado: `res3: List [Double] = List (1.0, 5.5) ''.

¿Dónde están los elementos que agregué? ¿Y cómo agrego estos elementos correctamente para que cuando llamo l obtenga una nueva lista con todas las cosas que agregué?

Answer 1

Como desea agregar elementos a la lista existente, puede usar var List [Int] y luego continuar añadiendo elementos a la misma lista. Nota -> Debe asegurarse de insertar un elemento en la lista existente de la siguiente manera:

var l: List [int] = List () // crea una lista vacía

l = 3 :: l // agrega 3 al encabezado de la lista

l = 4 :: l // hace que int 4 sea el jefe de la lista

// Ahora cuando imprimas l, verás dos elementos en la lista (4, 3)

Answer 2

Estás usando una lista inmutable. Las operaciones en la lista devuelven una nueva lista. La lista anterior permanece sin cambios. Esto puede ser muy útil si otra clase / método contiene una referencia a la colección original y se basa en que permanezca sin cambios. Puede usar diferentes vals con nombre como en

val myList1 = 1.0 :: 5.5 :: Nil
val myList2 = 2.2 :: 3.7 :: mylist1

o use una var como en

var myList = 1.0 :: 5.5 :: Nil
myList :::= List(2.2, 3.7)

Esta es la sintaxis equivalente para:

myList = myList.:::(List(2.2, 3.7))

O puede usar una de las colecciones mutables como

val myList = scala.collection.mutable.MutableList(1.0, 5.5)
myList.++=(List(2.2, 3.7))

No debe confundirse con lo siguiente que no modifica la lista mutable original, pero devuelve un nuevo valor:

myList.++:(List(2.2, 3.7))

Sin embargo, solo debe usar colecciones mutables en el código de rendimiento crítico. Las colecciones inmutables son mucho más fáciles de razonar y usar. Una gran ventaja es que la lista inmutable y scala.collection.immutable.Vector son covariantes. No te preocupes si eso no significa nada para ti todavía. La ventaja de esto es que puedes usarlo sin entenderlo completamente. Por lo tanto, la colección que estaba utilizando por defecto es en realidad scala.collection.immutable.List acaba de ser importada automáticamente.

Tiendo a usar List como mi colección predeterminada. Desde 2.12.6 Seq se establece por defecto en Seq inmutable antes de que esto se convirtiera en inmutable.

Answer 3

Trataré de explicar los resultados de todos los comandos que probaste.

scala> val l = 1.0 :: 5.5 :: Nil
l: List[Double] = List(1.0, 5.5)

En primer lugar, List es un alias de tipo a scala.collection.immutable.List (definido en Predef.scala).

Usar el objeto List companion es una forma más directa de crear una instancia de una List . Ej .: List(1.0,5.5)

scala> l
res0: List[Double] = List(1.0, 5.5)
scala> l ::: List(2.2, 3.7)
res1: List[Double] = List(1.0, 5.5, 2.2, 3.7)

::: devuelve una lista resultante de la concatenación del prefijo de lista dado y esta lista

La lista original NO está modificada

scala> List(l) :+ 2.2
res2: List[Any] = List(List(1.0, 5.5), 2.2)

List(l) es una List[List[Double]] Definitivamente no es lo que quiere.

:+ devuelve una nueva lista que consta de todos los elementos de esta lista seguidos de elem.

El tipo es List[Any] porque es la superclase común entre List[Double] y Double

scala> l
res3: List[Double] = List(1.0, 5.5)

l se deja sin modificar porque ningún método en immutable.List modificó la lista.

Answer 4

Use import scala.collection.mutable.MutableList o similar si realmente necesita una mutación.

import scala.collection.mutable.MutableList
val x = MutableList(1, 2, 3, 4, 5)
x += 6 // MutableList(1, 2, 3, 4, 5, 6)
x ++= MutableList(7, 8, 9) // MutableList(1, 2, 3, 4, 5, 6, 7, 8, 9)