Suena como una pregunta estúpida, pero todos los que he encontrado en la internet era basura.
Yo, simplemente, no puede agregar un elemento de tipo T en una lista List[T].
He probado con myList ::= myElement pero parece que se crea un objeto extraño y acceso a myList.last siempre devuelve el primer elemento que se coloca dentro de la lista.

InformationsquelleAutor Masiar | 2011-10-17

5 Comentarios

  1. 358
    List(1,2,3) :+ 4
    
    Results in List[Int] = List(1, 2, 3, 4)

    Tenga en cuenta que esta operación tiene una complejidad de O(n). Si usted necesita esta operación con frecuencia, o para listas largas, considere el uso de otro tipo de datos (por ejemplo, un ListBuffer).

    • Es O(n) porque se invierte la lista, añade el elemento a la cabeza, y luego se invierte una vez más? O es que O(2*n)?
    • No hay ningún O(2*n), constante de factores se tienen en cuenta para asintótica complejidades. Creo que el List se convierte en un ListBuffer, el elemento se anexa, y el ListBuffer convierte de nuevo (casi tanto como String y StringBuilder en Java), pero eso es sólo una conjetura.
    • Es de O(n) ya que al recorrer la lista por completo con el fin de alcanzar el último elemento puntero y ser capaz de añadir el elemento haciendo que el último elemento puntero que apunte a él.
    • si ese es el caso, sólo pudo mantener un puntero a la cabeza y la cola. Sin embargo, la lista en la scala es inmutable, es decir, que para «modificar» el último elemento de la lista que uno necesita para hacer una copia de ella en primer lugar. Su copia, que es O(n) – no el recorrido de la propia lista.
    • Yo creo que es O(n), simplemente porque crea una nueva lista de
    • no hay ninguna constante de los factores de complejidad asintótica de las clases, que no impiden su uso en la descripción de la complejidad asintótica =)
    • Por lo que hace a los contras operador :: tiene una complejidad de O(n) como así? No puede el compilador de scala optimizar las operaciones de la forma en que por ejemplo, haskell hace?
    • Los contras operador tiene complejidad O(1), ya que se trabaja en la «intención» de la lista.
    • UNA MALA RESPUESTA. No anexar a la lista. Crea una nueva lista en su lugar.
    • estás trolling? Por supuesto, usted no puede modificar una inmutable lista, duh…
    • No, los contras operador :: devuelve un nuevo List donde la cabeza es el nuevo elemento y la cola es el antiguo List. Esto se puede hacer porque Lists son inmutables, por lo Scala «sabe» de la lista original no cambia y por lo tanto puede ser reutilizado como la cola de la nueva List. Esto se puede hacer en O(1) porque no dependen del tamaño de la lista. Pero se podría preguntar por qué este no es el caso de anexar al final; no puede el mismo razonamiento se utiliza? Bueno, no, porque de cómo la List constructor está escrito: inmutable List en Scala es construido a partir de un head y un tail.
    • Nota la lista original no se cambia, se crea otra lista, pero no se asigna a ninguna. Para cambiar de lugar, o bien asignar a la lista anterior, o el uso ListBuffer anexar sin asignación, como: import scala.collection.mutable.ListBuffer \ var l = ListBuffer[String]() \ l += "a" \ l += "b"

  2. 64

    Eso es porque usted no lo haga (al menos con una inmutable de la lista).
    Si usted realmente necesita para añadir un elemento al final de una estructura de datos y de esta estructura de datos que realmente necesita realmente ser una lista y esta lista realmente tiene que ser inmutable, a continuación, hacer eiher este:

    (4 :: List(1,2,3).reverse).reverse

    o que:

    List(1,2,3) ::: List(4)
    • Muchas gracias! Eso era exactamente lo que yo estaba buscando. Supongo que a partir de su respuesta que no se debe hacer, aunque… voy a revisar mi estructura y ver qué puedo hacer. Gracias de nuevo.
    • el uso de un Vector si desea inmutabilidad y eficiente anexar. Ver la sección características de rendimiento en scala-lang.org/docu/files/collections-api/collections.html
    • La «compilación de la lista de anteponiendo y, a continuación, dar marcha atrás» es un útil patrón si usted tiene muchos de los elementos a añadir, pero creo que no es una buena idea para aplicarla como en el caso de añadir un elemento a una lista existente. La «doble reverse» truco reconstruye la lista dos veces, mientras que :+, ineficiente, ya que puede ser, sólo reconstruye una vez.
    • jajaja que gracioso un poco
  3. 20

    Listas en Scala no están diseñados para ser modificado. De hecho, usted no puede agregar elementos a un Scala Lista; es una inmutable estructura de datos, como un Java Cadena.
    Lo que realmente hace al «añadir un elemento a una lista» en la Scala es crear un nueva Lista a partir de una Lista existente. (Fuente)

    Lugar de usar las listas para tales casos de uso, le sugiero que utilice un ArrayBuffer o un ListBuffer. Los datastructures están diseñados para tener nuevos elementos que se añaden.

    Finalmente, después de todas sus operaciones se realizan, el búfer luego se pueden convertir en una lista. Consulte el siguiente REPL ejemplo:

    scala> import scala.collection.mutable.ListBuffer
    import scala.collection.mutable.ListBuffer
    
    scala> var fruits = new ListBuffer[String]()
    fruits: scala.collection.mutable.ListBuffer[String] = ListBuffer()
    
    scala> fruits += "Apple"
    res0: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple)
    
    scala> fruits += "Banana"
    res1: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana)
    
    scala> fruits += "Orange"
    res2: scala.collection.mutable.ListBuffer[String] = ListBuffer(Apple, Banana, Orange)
    
    scala> val fruitsList = fruits.toList
    fruitsList: List[String] = List(Apple, Banana, Orange)
  4. 2

    Esto es similar a una de las respuestas, pero en la manera diferente :

    scala> val x=List(1,2,3)
    x: List[Int] = List(1, 2, 3)
    
    scala> val y=x:::4::Nil
    y: List[Int] = List(1, 2, 3, 4)
  5. 1

    Podemos agregar o anteponer dos listas o lista de&matriz

    Anexar:

    var l = List(1,2,3)    
    l=l:+4 
    Result : 1 2 3 4  
    var ar = Array(4,5,6)    
    for(x<-ar)    
    { l=l:+x}  
      l.foreach(println)
    
    Result:1 2 3 4 5 6

    Anteponiendo:

    var l = List[Int]()  
       for(x<-ar)  
        { l=x::l } //prepending    
         l.foreach(println)   
    
    Result:6 5 4 1 2 3
    • Sí, se puede, pero sería una mala idea por todas las razones mencionadas en las otras respuestas.

Dejar respuesta

Please enter your comment!
Please enter your name here