scala ajouter à une LinkedList mutable

Veuillez cocher cette

import scala.collection.mutable.LinkedList

var l = new LinkedList[String]

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

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

mais

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)

Pourquoi le deuxième extrait de code fonctionne, mais le premier ne marche pas? C'est sur Scala 2.10

source d'informationauteur weima

La documentation dit If this is empty then it does nothing and returns that. Otherwise, appends that to this.. C'est exactement, ce que vous avez observé. Si vous avez vraiment besoin d'une mutable liste, je vous suggère d'utiliser scala.collection.mutable.ListBuffer au lieu de cela, avec elle, vous pouvez faire

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)

3

Je comprends qu'elle est liée à la Première/Dernière (Nil) de l'élément dans la liste (si la liste est vide Nil est le premier et le dernier élément dans le même temps).

LinkedList (encore) suit "charme primitif" de la stratégie. De sorte qu'il n'essayez pas d'ajouter/ajouter de nouvelles données à/après Nilpour avoir des résultat comme ceci: {Nul, newElement}. (Après tout Nil doit être le dernier élément)

Bien sûr, il pourrait vérifier if liste est vide, puis mettre addingList au début et à la Nil à la fin. Mais ce serait "trop intelligent", je suppose.

Mais, de toute façon append() renvoie "attend" le résultat de ce genre:
```
val addingList = new LinkedList[String]("a", "b")
val result = emptyList append addingList
```
result = {"a", "b"}. Dans ce cas, elle renvoie 'addingList' elle-même, et/mais ne change pas de la liste initiale.

Si nous essayons d'attribuer newElement à la next ref:
```
   emptyList.next = LinkedList("whatever")
```
Comme conséquence, nous avons emtyList modifié comme ceci:
```
 LinkedList(null, whatever)
```
I. e. il crée poing élément nullpuisque nous avons utilisé next() l'attribution/l'élément suivant. Donc il se déplace Nul à la fin, parce que le premier élément qui est nulle, a ensuite référence à l'élément nouveau, nous avons ajouté (addingElelement).

Parce que

"le "emptyList" est aussi le "chef" lien"

la tête et dans notre cas, la tête est Nilmais Nill ne peut pas avoir d'autre, il a de créer de nouveaux premier élément (qui est a la valeur null) avec next() referece à notre nouveau addingElelement.

Personnellement je trouve ça "trop primitifs" et pas "tellement élégant". Mais ça dépend, je suppose.

De tâches histoire:

Pour ma première tâche (pourquoi je commence à penser à cette "étrange" liste comportement [même si c'est mutable]), j'ai voulu utiliser mutable liste pour une classe/objet appelé Dictionary qui permettrait de garder Words (dictionnaire par défaut n'a pas les mots). Et je voudrais avoir des méthodes comme unddWord(wod:String) pour ajouter de nouveaux mots. Pour l'instant, ma mise en œuvre sera changé (je ne vais pas utiliser cette LinkedListmais plutôt MutableList. Il semble qu'il est plus mutable que la précédente):
```
object Dictionary {

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

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

}
```
Mais possible de la mise en œuvre pourrait être comme ceci:
```
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) )
    }

  }

}
```
Mais puis-je utiliser var au lieu de valet je dois transformer chaque nouvelle Mot à LinkedListet ma logique est devenu plus compliqué.

Vous devez vous connecter pour publier un commentaire.