接上一篇，这个问题还没完，泽斌给出这个问题是因另一个问题引发的：Scala 的 for each，为什么会有且仅有一次 recursion？ 引用原问题：

Scala 2.10/2.11 中，运行

val l = MutableList(16)

for (i<-l) {
    val p = i/2
    if (!(l contains p)) { 
        l += p 
    }
}

l

得到的是

MutableList[Int](16, 8, 4)

如果是返回 (16, 8)（如同 JavaScript 或 PHP）的话我能理解。或者是返回 (16, 8, 4, 2, 1, 0)（如同 Python 或 Ruby） 我也能够理解。但是返回 (16, 8, 4) 是为什么呢？

这得看看MutableList的迭代器实现了, 它在scala.collection.LinearSeqOptimized里面：

override /*IterableLike*/
def foreach[B](f: A => B) {
    var these = this
    while (!these.isEmpty) {
      f(these.head)
      these = these.tail
    }
}

不太容易直接看出来这块的问题，断点的时候发现这里会导致调试器在展示值时调用toString引起异常，我是复制了一份MutableList的代码在foreach里增加一些打印信息发现的。

我们在repl下模拟这个迭代过程，刚开始foreach的时候元素只有1个，对16进行处理，追加一个新元素8：

scala> val l = scala.collection.mutable.MutableList(16)
l: scala.collection.mutable.MutableList[Int] = MutableList(16)

scala> l += 8
res0: l.type = MutableList(16, 8)

这个追加的行为对应foreach里面的f(these.head)这一句，之后把指针指向后续链表节点：

scala> var these = l.tail
these: scala.collection.mutable.MutableList[Int] = MutableList(8)

因为刚开始var these=this，所以这次these=these.tail会得到链表的第二个元素8，然后传入8，原链表又被追加了一个元素4：

scala> l += 4
res1: l.type = MutableList(16, 8, 4)

接着继续移动指针，但这次these对象已经不是this而是单节点链表，取它的tail会得到空，导致foreach终止。所以最终原链表里有3个元素:

scala> these = these.tail
these: scala.collection.mutable.MutableList[Int] = MutableList()

虽然，这里的these与原链表是复用的，它size虽然为0，但实际可以访问后续元素：

scala> these(0)
res3: Int = 4

我觉得应该算是MutableList迭代器的bug了，它不应该使用LinearSeqOptimized里的实现，那个里面的逻辑没有考虑到集合长度可变的情况。

群里看到的问题：

scala> import scala.collection._

scala> val l = mutable.MutableList(1,2)
l: scala.collection.mutable.MutableList[Int] = MutableList(1, 2)

scala> val t = l.tail
t: scala.collection.mutable.MutableList[Int] = MutableList(2)

scala>  l += 3
res0: l.type = MutableList(1, 2, 3)

scala> t.length
res1: Int = 1

这里显示 t 的长度没有问题，但显示t的值的时候，却不是预期的：

scala> t
res2: scala.collection.mutable.MutableList[Int] = MutableList(2, 3)

怎么把l列表后来增加的3也给包含进去了。这要看这个MutableList的tail方法的实现是怎么回事了。

在 scala.collection.mutable.MutableList里为了实现scala.collection.GenTraversableLike特质里的head, tail等方法，是通过链表scala.collection.mutable.LinkedList来存储数据。它的tail方法实现如下：

override def tail: MutableList[A] = {
    val tl = new MutableList[A]
    tailImpl(tl)
    tl
}

// this method must be private for binary compatibility
private final def tailImpl(tl: MutableList[A]) {
    require(nonEmpty, "tail of empty list")
    tl.first0 = first0.tail
    tl.len = len - 1
    tl.last0 = if (tl.len == 0) tl.first0 else last0
}

这里面要看看 tl.first0 = first0.tail 的实现是什么，在LinkedListLike里：

override def tail: This = {
    require(nonEmpty, "tail of empty list")
    next
}

它直接返回当前链表的下一个节点引用。所以当原链表末尾附加新的值时，这个 tl 链表也是可以引用到的，因为它们是复用的。

不过因为对这个tl的len设置过了，所以迭代的时候，并不会越界。并且toString方法也不会多展示不属于它的数据的：

scala> t.toString
res14: String = MutableList(2)

scala> t.foreach(print)
2

但在repl的展示上，就没有做的很严谨了，它没有调用这个对象的toString来展示它的值，而是自己把这个节点及链表后续节点的值都展示了：

scala> t
res15: scala.collection.mutable.MutableList[Int] = MutableList(2, 3)

这应该算是repl展示层面的不严谨吧。不过MutableList的实现也不太严谨，这个t虽然length是1，但后边节点如果有值的话也是可以索引到的：

scala> t(0)
res17: Int = 2

scala> t(1)
res18: Int = 3

scala> l += 4
res19: l.type = MutableList(1, 2, 3, 4)

scala> t(2)
res20: Int = 4

这也算是一个陷阱吧，mutable的集合在使用的时候要清楚它的场景和限制。