arreglo - scala java array

scala adjuntar a una LinkedList mutable

Question

Por favor, chequee esto

import scala.collection.mutable.LinkedList

var l = new LinkedList[String]

l append LinkedList("abc", "asd")

println(l)
// prints 
// LinkedList()

pero

import scala.collection.mutable.LinkedList

var l = new LinkedList[String]

l = LinkedList("x")
l append LinkedList("abc", "asd")

println(l)
// prints 
// LinkedList(x, abc, asd)

¿Por qué funciona el segundo fragmento de código pero el primero no? Esto está en Scala 2.10

Answer 1

La documentación dice: If this is empty then it does nothing and returns that. Otherwise, appends that to this. If this is empty then it does nothing and returns that. Otherwise, appends that to this. . Eso es exactamente, lo que observaste. Si realmente necesita una lista mutable, le sugeriría que utilice scala.collection.mutable.ListBuffer en scala.collection.mutable.ListBuffer lugar, con esto puede hacerlo

val lb = new ListBuffer[Int]

scala> lb += 1
res14: lb.type = ListBuffer(1)

scala> lb
res15: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1)

scala> lb ++= Seq(1,2,3)
res17: lb.type = ListBuffer(1, 1, 2, 3, 1, 2, 3)

scala> lb
res18: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 1, 2, 3, 1, 2, 3)

Answer 2

Según entiendo, está relacionado con el elemento Primero / Último ( Nil ) en la lista (si la lista está vacía, Nil es el primer y último elemento al mismo tiempo).

LinkedList (todavía) sigue la estrategia de " encanto primitivo ". Por lo tanto, no intenta agregar / agregar datos nuevos a / después de Nil , para tener un posible resultado como este: {Nil, newElement}. (Después de todo Nil debería ser el último elemento)

Por supuesto, se podría verificar if lista está vacía, luego poner addingList al principio y Nil al final. Pero esto sería "demasiado inteligente", supongo.

Pero, de todos modos, append() devuelve un resultado "esperado" como este:

val addingList = new LinkedList[String]("a", "b")
val result = emptyList append addingList

result = {"a", "b"}. En este caso, devuelve el ''addistlist'' y / pero no cambia la lista inicial.

Si intentamos asignar newElement a la next referencia:

   emptyList.next = LinkedList("whatever")

Como resultado habríamos cambiado emtyList así:

 LinkedList(null, whatever)

Es decir , crea un primer elemento como nulo , ya que hemos usado next() asignándole un nuevo elemento / next. Por lo tanto, mueve Nil al final, porque el primer elemento que es nulo, tiene la siguiente referencia al nuevo elemento que agregamos ( addingElelement ).

Porque

"the" emptyList "es también el enlace" head ""

y la cabecera en nuestra cabecera de caso es Nil , pero Nill no puede tener el siguiente, por lo que tiene que crear un primer elemento nuevo (que tiene un valor nulo) con la referencia next () a nuestro nuevo elemento de addingElelement .

Personalmente lo encuentro "demasiado primitivo" y no "muy elegante". Pero depende, supongo.

Historia orientada a la tarea:

Para mi tarea inicial (por qué empiezo a pensar en este comportamiento de lista ''extraño'' [aunque es mutable]), quería usar una lista mutable para una clase / objeto llamado Dictionary que mantendría Words en ella (el diccionario por defecto no lo ha hecho). cualquier palabra). Y tendría métodos como ddWord(wod:String) para agregar nuevas palabras. Por ahora se cambiará mi implementación (no voy a usar esta lista LinkedList , sino la lista MutableList . Parece que es más mutable que la anterior):

object Dictionary {

  val words = new mutable.MutableList[Word]();

  def addWord(word: Word): Unit = {
    words += word;
  }

}

Pero la posible implementación podría ser así:

object Dictionary {

  var words = new mutable.LinkedList[Word]();

  def addWord(word: Word): Unit = {

    if (words.isEmpty) {
      words = words append( mutable.LinkedList[Word](word) ) // rely on append result
    } else {
      words append( mutable.LinkedList[Word](word) )
    }

  }

}

Pero luego tengo que usar var lugar de val , y debo transformar cada palabra nueva en LinkedList , y mi lógica se volvió más complicada.