Scala 中的集合（三）：实现一个新的 Collection 类

本文由 Yison 发表在 ScalaCool 团队博客。

Scala 中的 collection 库是符合 DRY 设计原则的典范，它包含了大量通用的集合操做 API，由此咱们能够基于标准库，轻松构建出一个强大的新集合类型。

本文将介绍「如何实现一个新集合类」，在开始以前，咱们先来了解下 Scala 2.8 版本后的集合结构设计。

集合通用设计

看过 Scala 中的集合（一） 的朋友已经知道，Scala 的集合类系统地区分了可变的和不可变的集合，它们存在于如下三个包中：

• scala.collection
• scala.collection.mutable
• scala.collection.immutable

然而，以上全部的集合都继承了两个相同的特质 — Traversable 和 Iterable（后者继承了前者）。

Traversable

Traversable 是集合类最高级的特性，它具备一个抽象方法：

def foreach[U](f: Elem => U)复制代码

顾名思义，foreach 方法用于遍历集合类的全部元素，而后进行指定的操做。Iterable 继承了 Traversable，也实现了 foreach 方法，继而全部继承了 Iterable 的集合类同时也得到了一个 foreach 的基础版本。

不少集合操做都是基于 foreach 实现，所以它的性能很是关键。一些 Iterable 子类覆写了这个方法的实现，从而得到了符合不一样集合特性的优化。

那么，常见的集合类型（如 Seq） 是如何实现通用操做的呢（如 map）？

原来，Traversable 除了惟一的抽象方法之外，还包含了大量通用的集合操做方法。

Scala 文档对这些操做方法进行了归类，以下所示：

分类	方法
抽象方法	foreach
相加	++
Map	map / flatMap / collect
集合转换	toArray / toList / toIterable / toSeq / toIndexedSeq / toStream / toSet / toMap
拷贝	copyToBuffer / copyToArray
size 信息	isEmpty / nonEmpty / size / hasDefiniteSize
元素检索	head / last / headOption / lastOption / find
子集合检索	tail / init / slice / take / drop / takeWhilte / dropWhile / filter / filteNot / withFilter
拆分	splitAt / span / partition / groupBy
元素测试	exists / forall / count
折叠	foldLeft / foldRight / /: / :\ / reduceLeft / reduceRight
特殊折叠	sum / product / min / max
字符串转化	mkString / addString / stringPrefix
视图生成	view

由此，一个集合仅需定义 foreach 方法，以上全部其它方法均可以从 Traversable 继承。

Iterable

Scala 当前版本的 Iterable 设计略显尴尬，它实现了 Traversable，也同时被其它全部集合实现。然而事实上这并非一个好的设计，缘由以下：

• Traversable 具备隐式的行为假设，它在公开的签名中是不可见的，容易致使 API 出错
• 遍历一个 Traversable 比 Iterable 性能要差
• 全部继承了 Traversable 的数据类型，无不接受 Iterator 的实现，前者显得多余

详情参见 @Alexelcu 的文章 — Why scala.collection.Traversable Is Bad Design

所以，正在进行的 Scala collection redesign 项目也已经抛弃了 Traversable。

然而，这并不妨碍咱们研究 Iterable 中的通用方法，它们也在 collection-strawman 中被保留，以下所示：

分类	方法
抽象方法	iterator
其余迭代器	grouped / sliding
子集合	takeRight / dropRight
拉链操做	zip / zipAll
比对	sameElements

Builder 类

几乎全部的集合操做都由「遍历器」和「构建器」完成，在了解以上内容以后，咱们再来了解下如何构建一个集合类型。在当前的 Scala 中，是利用一个 Builder 类实现的。

package scala.collection.mutable
class Builder[-Elem, +To] {
  def +=(elem: Elem): this.type
  def result(): To
  def clear(): Unit
  def mapResult[NewTo](f: To => NewTo): Builder[Elem, NewTo] = ...
}复制代码

注意类型参数，Elem 表示元素的类型（如 Int ），To 表示集合的类型（如 Array[Int]）。

此外：

• += 能够增长元素
• result 返回一个集合
• clear 把集合重置为空状态
• mapResult 返回一个 Builder，拥有新的集合类型

咱们来看下Builder 如何结合 foreach 方法，实现常见的 filter 操做：

def filter(p: Elem => Boolean): Repr = {
  val b = newBuilder
  foreach { elem => if (p(elem)) b += elem }
  b.result
}复制代码

So easy！没什么挑战。

咱们再来考虑下 map，它与 filter 的差别之一，在于前者能够返回一个「元素类型不一样」的集合。如：

scala > List(1, 2, 3).map(_.toString)
res0: List[String] = List(1, 2, 3)复制代码

这下有难度了，仅凭 Builder 和 foreach 组合，彷佛完成不了这个任务。

因而，咱们决定看下 TraversableLike 中 map 的 Scala 源码实现：

def map[B, That](f: Elem => B)
    (implicit bf: CanBuildFrom[Repr, B, That]): That = {
  val b = bf(this)
  this.foreach(x => b += f(x))
  b.result
}复制代码

当前 Scala 集合中，???Like 命名的特质是 ??? 特质的实现。

一个大发现 — 当前版本的 Scala 原来是利用 CanBuildFrom 类型来解决如何集合「类型转换」的问题。

package scala.collection.generic
trait CanBuildFrom[-From, -Elem, +To] {
  // 建立一个新的构造器(builder)
  def apply(from: From): Builder[Elem, To]
}复制代码

这种利用 TypeClass 技术 — 采用隐式转换来得到扩展的方式，显得强大且灵活，但在新手看来会比较怵。

经过字面的理解，咱们知晓 — From 表明当前的集合类型，Elem 表明元素类型，To 表明目标集合的类型。
因此咱们能够如此解读 CanBuildFrom：「有这么一个方法，由给定的 From 类型的集合，使用 Elem 类型，创建 To 类型的集合」。

新集合类实现

经过以上的介绍，你们对 Scala 的集合结构设计有了总体的认识，如今开始来实现一个新的集合类。

如下例子来自 Scala 文档，细节有调整，精简。

假设咱们须要设计一套新的「密文编码序列」，由最基本的 A、B、C、D 四个字母组成。定义类型以下：

abstract class Base
case object A extends Base
case object B extends Base
case object C extends Base
case object D extends Base
object Base {
  val fromInt: Int => Base = Array(A, B, C, D)
  val toInt: Base => Int = Map(A -> 0, B -> 1, C -> 2, D -> 3)
}复制代码

显然，咱们可使用 Seq[Base] 来表示一个密文序列，但因为这个密文可能很长，而且 Base 类型只有 4 种可能，咱们能够经过「位计算」的方式来开发一种压缩过的集合，它是 Seq[Base] 的子类。

如下将采用伴生对象的方式来建立 Message 实例，可参考 Builder 建立者模式

import collection.IndexedSeqLike

final class Message private ( val groups: Array[Int], val length: Int) extends IndexedSeq[Base] {
  import Message._
  def apply(idx: Int): Base = {
    if (idx < 0 || length <= idx)
      throw new IndexOutOfBoundsException
    Base.fromInt(groups(idx / N) >> (idx % N * S) & M)
  }
}

object Message {
  private val S = 2 // 表示一组所须要的位数 
  private val N = 32 / S  // 一个Int可以放入的组数 
  private val M = (1 << S) - 1 // 分离组的位掩码(bitmask)
  def fromSeq(buf: Seq[Base]): Message = {
    val groups = new Array[Int]((buf.length + N - 1) / N)
    for (i <- 0 until buf.length)
      groups(i / N) |= Base.toInt(buf(i)) << (i % N * S)
    new Message(groups, buf.length)
  }
  def apply(bases: Base*) = fromSeq(bases)
}复制代码

测试：

val message = Message(A, B, B ,D)
println(message.length) // 4
println(message.last) // D
println(message.take(3)) // Vector(A, B, B)复制代码

• Message 很好地得到了 IndexedSeq 的通用集合方法，如 length、last
• 但 take 方法并无得到预期的 Message(A, B, B)，而是 Vector(A, B, B)

改进一下：

def take(count: Int): Message = Message.fromSeq(super.take(count))复制代码

• 确实能够解决 take 返回动态类型的问题，可获得 Message(A, B, B)的结果
• 然而集合除了 take 外还有大量通用方法，覆写每一个方法的策略不可取

正确的姿式

import collection.mutable.{Builder, ArrayBuffer}
import collection.generic.CanBuildFrom复制代码

在伴生类中从新实现 newBuilder ：

final class Message private (val groups: Array[Int], val length: Int)
  extends IndexedSeq[Base] with IndexedSeqLike[Base, Message] {
  import Message._

  // 在IndexedSeq中必须从新实现newBuilder
  override protected[this] def newBuilder: Builder[Base, Message] =
    Message.newBuilder

  def apply(idx: Int): Base = {
    ……
  }

}复制代码

改写伴生对象：

object Message {
  ……
  def fromSeq(buf: Seq[Base]): Message = {
    ……
  }

  def apply(bases: Base*) = fromSeq(bases)

  def newBuilder: Builder[Base, Message] =
    new ArrayBuffer mapResult fromSeq

  implicit def canBuildFrom: CanBuildFrom[Message, Base, Message] =
    new CanBuildFrom[Message, Base, Message] {
      def apply(): Builder[Base, Message] = newBuilder
      def apply(from: Message): Builder[Base, Message] = newBuilder
    }
}复制代码

此外，如前文提到，咱们还能够从新实现 foreach 方法来提升该集合类的效率：

final class Message private (val groups: Array[Int], val length: Int)
  extends IndexedSeq[Base] with IndexedSeqLike[Base, Message] {
  ……
  override def foreach[U](f: Base => U): Unit = {
    var i = 0
    var b = 0
    while (i < length) {
      b = if (i % N == 0) groups(i / N) else b >>> S
      f(Base.fromInt(b & M))
      i += 1
    }
  }
}复制代码

以上，咱们便构建了一个新的集合类型 Message，经过极少的代码，拥有了强大的通用集合特性。

咱们将在下一篇文章中进一步介绍 CanBuildFrom ，几乎肯定地说，它也会在将来的 Scala 版本中被新的方案替代。

参考

• Scala’s Collections Library
• The Architecture of Scala Collections