Scala 2.8 集合设计教程

前言

Martin Odersky 的 2.8 collection walk-through 应该是您的第一个参考。 architectural notes 也对其进行了补充，这对于那些想要设计自己的系列的人来说会特别感兴趣。

这个答案的其余部分是在任何此类事情存在之前编写的（事实上，在 2.8.0 本身发布之前）。

您可以在 Scala SID #3 中找到一篇关于它的论文。对于那些对 Scala 2.7 和 2.8 之间的差异感兴趣的人来说，该领域的其他论文也应该很有趣。

我将选择性地引用论文中的内容，并补充我的一些想法。还有一些图像，由 Matthias 在 decodedified.com 生成，原始 SVG 文件可以在 here 中找到。

集合类/特征本身

集合实际上有三种特征层次结构：一种用于可变集合，一种用于不可变集合，一种对集合不做任何假设。

Scala 2.9 引入了并行、串行和可能并行集合之间的区别。我将在下一节中讨论它们。本节中描述的层次结构专门指非并行集合。

https://i.stack.imgur.com/bSVyA.png

显示的所有元素都是特征。在另外两个层次结构中，也有直接继承特征的类以及通过隐式转换为包装类而被视为属于该层次结构的类。这些图表的图例可以在它们之后找到。

https://i.stack.imgur.com/2fjoA.png

https://i.stack.imgur.com/Dsptl.png

传奇：

https://i.stack.imgur.com/szWUr.png

这是集合层次结构的缩写 ASCII 描述，供那些看不到图像的人使用。

                    Traversable
                         |
                         |
                      Iterable
                         |
      +------------------+--------------------+
     Map                Set                  Seq
      |                  |                    |
      |             +----+----+         +-----+------+
    Sorted Map  SortedSet   BitSet   Buffer Vector LinearSeq

并行集合

当 Scala 2.9 引入并行集合时，设计目标之一是尽可能无缝地使用它们。用最简单的术语来说，可以用并行集合替换非并行（串行）集合，并立即获得收益。

然而，由于在此之前的所有集合都是串行的，因此许多使用它们的算法假设并依赖于它们是串行的事实。以此类假设提供给方法的并行集合将失败。出于这个原因，上一节中描述的所有层次结构都要求串行处理。

创建了两个新的层次结构来支持并行集合。

并行集合层次结构具有相同的特征名称，但以 Par 开头：ParIterable、ParSeq、ParMap 和 ParSet。请注意，没有 ParTraversable，因为任何支持并行访问的集合都能够支持更强的 ParIterable 特征。它也没有序列层次结构中存在的一些更专业的特征。整个层次结构位于目录 scala.collection.parallel 下。

实现并行集合的类也有所不同，ParHashMap 和 ParHashSet 用于可变和不可变并行集合，ParRange 和 ParVector 实现 immutable.ParSeq，ParArray 实现 mutable.ParSeq。

另一个层次结构也反映了串行和并行集合的特征，但带有前缀 Gen：GenTraversable、GenIterable、GenSeq、GenMap 和 GenSet。这些特征是并行和串行集合的父母。这意味着采用 Seq 的方法无法接收并行集合，但采用 GenSeq 的方法预计可用于串行和并行集合。

鉴于这些层次结构的结构方式，为 Scala 2.8 编写的代码与 Scala 2.9 完全兼容，并且需要串行行为。如果不重写，它就无法利用并行集合，但所需的更改非常小。

使用并行集合

任何集合都可以通过调用方法 par 转换为并行集合。同样，任何集合都可以通过调用方法 seq 转换为串行集合。

如果集合已经是请求的类型（并行或串行），则不会发生转换。但是，如果在并行集合上调用 seq 或在串行集合上调用 par，则会生成具有所请求特征的新集合。

不要将 seq（将集合转换为非并行集合）与 toSeq（返回从集合元素创建的 Seq）混淆。对并行集合调用 toSeq 将返回 ParSeq，而不是串行集合。

主要特征

虽然有许多实现类和子特征，但层次结构中有一些基本特征，每个特征都提供更多方法或更具体的保证，但减少了可以实现它们的类的数量。

在以下小节中，我将简要描述主要特征及其背后的想法。

特征 TraversableOnce

此特征与下面描述的特征 Traversable 非常相似，但有一个限制，即您只能使用它一次。也就是说，在 TraversableOnce 可能 上调用的任何方法都会使其无法使用。

此限制使集合和 Iterator 之间共享相同的方法成为可能。这使得使用 Iterator 但不使用特定于 Iterator 的方法的方法实际上能够处理任何集合以及迭代器，如果重写为接受 TraversableOnce。

因为 TraversableOnce 统一了集合和迭代器，所以它没有出现在前面的图中，它们只关注集合。

特征可遍历

collection 层次结构的顶部是特征 Traversable。它唯一的抽象操作是

def foreach[U](f: Elem => U)

该操作旨在遍历集合的所有元素，并将给定的操作 f 应用于每个元素。该应用程序仅针对其副作用进行；实际上 f 的任何函数结果都会被 foreach 丢弃。

可遍历的对象可以是有限的或无限的。自然数流 Stream.from(0) 是无限可遍历对象的一个示例。方法 hasDefiniteSize 指示集合是否可能是无限的。如果 hasDefiniteSize 返回 true，则集合肯定是有限的。如果它返回 false，则该集合尚未完全详细说明，因此它可能是无限的或有限的。

此类定义了可以根据 foreach 有效实现的方法（其中超过 40 个）。

特征可迭代

这个 trait 声明了一个抽象方法 iterator，它返回一个迭代器，该迭代器一个一个地产生所有集合的元素。 Iterable 中的 foreach 方法是根据 iterator 实现的。 Iterable 的子类通常使用直接实现覆盖 foreach 以提高效率。

类 Iterable 还向 Traversable 添加了一些不常用的方法，只有在 iterator 可用时才能有效地实现这些方法。它们总结如下。

xs.iterator          An iterator that yields every element in xs, in the same order as foreach traverses elements.
xs takeRight n       A collection consisting of the last n elements of xs (or, some arbitrary n elements, if no order is defined).
xs dropRight n       The rest of the collection except xs takeRight n.
xs sameElements ys   A test whether xs and ys contain the same elements in the same order

其他特征

在 Iterable 之后是三个继承自它的基本特征：Seq、Set 和 Map。这三个都有一个 apply 方法并且所有三个都实现了 PartialFunction 特征，但是 apply 的含义在每种情况下都是不同的。

我相信 Seq、Set 和 Map 的含义很直观。在它们之后，这些类分解为特定的实现，这些实现提供了关于性能的特定保证，以及它因此而提供的方法。还可以使用一些经过进一步改进的特征，例如 LinearSeq、IndexedSeq 和 SortedSet。

下面的列表可能会有所改进。发表评论并提出建议，我会修复它。

基类和特征

Traversable——基本集合类。只需使用 foreach 即可实现。 TraversableProxy -- Traversable 的代理。只需将自己指向真正的收藏。 TraversableView -- 带有一些非严格方法的 Traversable。 TraversableForwarder -- 将大多数方法转发到底层，除了 toString、hashCode、equals、stringPrefix、newBuilder、view 和所有创建相同类型的新可迭代对象的调用。 mutable.Traversable 和 immutable.Traversable -- 与 Traversable 相同，但限制了集合类型。存在其他特殊情况的 Iterable 类，例如 MetaData。 Iterable -- 可以创建 Iterator 的集合（通过迭代器）。 IterableProxy、IterableView、可变和不可变.Iterable。

TraversableProxy -- Traversable 的代理。只需将自己指向真正的收藏。

TraversableView -- 带有一些非严格方法的 Traversable。

TraversableForwarder -- 将大多数方法转发到底层，除了 toString、hashCode、equals、stringPrefix、newBuilder、view 和所有创建相同类型的新可迭代对象的调用。

mutable.Traversable 和 immutable.Traversable -- 与 Traversable 相同，但限制了集合类型。

存在其他特殊情况的 Iterable 类，例如 MetaData。

Iterable -- 可以创建 Iterator 的集合（通过迭代器）。 IterableProxy、IterableView、可变和不可变.Iterable。

IterableProxy、IterableView、可变和不可变.Iterable。

迭代器——不是 Traversable 的后代的特征。定义 next 和 hasNext。 CountedIterator -- 定义计数的迭代器，它返回到目前为止看到的元素。 BufferedIterator——定义head，它返回下一个元素而不消耗它。存在其他特殊情况的迭代器类，例如 Source。

CountedIterator -- 定义计数的迭代器，它返回到目前为止看到的元素。

BufferedIterator——定义head，它返回下一个元素而不消耗它。

存在其他特殊情况的迭代器类，例如 Source。

地图

Map -- Tuple2 的 Iterable，它还提供了在给定键（元组的第一个元素）的情况下检索值（元组的第二个元素）的方法。也扩展了 PartialFunction。 MapProxy——地图的代理。 DefaultMap -- 实现 Map 的一些抽象方法的特征。 SortedMap -- 其键已排序的 Map。 immutable.SortMap immutable.TreeMap -- 实现 immutable.SortedMap 的类。 immutable.Map immutable.MapProxy immutable.HashMap -- 通过键散列实现 immutable.Map 的类。 immutable.IntMap -- 一个实现 immutable.Map 的类，专门用于 Int 键。使用基于键的二进制数字的树。 immutable.ListMap -- 通过列表实现 immutable.Map 的类。 immutable.LongMap -- 一个实现 immutable.Map 的类，专门用于 Long 键。请参阅 IntMap。还有针对特定数量的元素进行了优化的其他类。 mutable.Map mutable.HashMap -- 通过键散列实现 mutable.Map 的类。 mutable.ImmutableMapAdaptor -- 从现有的 immutable.Map 实现 mutable.Map 的类。 mutable.LinkedHashMap -- ? mutable.ListMap -- 通过列表实现 mutable.Map 的类。 mutable.MultiMap -- 一个类，每个键接受多个不同的值。 mutable.ObservableMap -- 一个 mixin，当与 Map 混合时，通过 Publisher 接口向观察者发布事件。 mutable.OpenHashMap -- 基于开放散列算法的类。 mutable.SynchronizedMap -- 一个 mixin，它应该与 Map 混合以提供一个带有同步方法的版本。可变的.MapProxy。

MapProxy——地图的代理。

DefaultMap -- 实现 Map 的一些抽象方法的特征。

SortedMap -- 其键已排序的 Map。 immutable.SortMap immutable.TreeMap -- 实现 immutable.SortedMap 的类。

immutable.SortMap immutable.TreeMap -- 实现 immutable.SortedMap 的类。

immutable.TreeMap -- 一个实现 immutable.SortedMap 的类。

immutable.Map immutable.MapProxy immutable.HashMap -- 通过键散列实现 immutable.Map 的类。 immutable.IntMap -- 一个实现 immutable.Map 的类，专门用于 Int 键。使用基于键的二进制数字的树。 immutable.ListMap -- 通过列表实现 immutable.Map 的类。 immutable.LongMap -- 一个实现 immutable.Map 的类，专门用于 Long 键。请参阅 IntMap。还有针对特定数量的元素进行了优化的其他类。

不可变的.MapProxy

immutable.HashMap -- 通过键散列实现 immutable.Map 的类。

immutable.IntMap -- 一个实现 immutable.Map 的类，专门用于 Int 键。使用基于键的二进制数字的树。

immutable.ListMap -- 通过列表实现 immutable.Map 的类。

immutable.LongMap -- 一个实现 immutable.Map 的类，专门用于 Long 键。请参阅 IntMap。

还有针对特定数量的元素进行了优化的其他类。

mutable.Map mutable.HashMap -- 通过键散列实现 mutable.Map 的类。 mutable.ImmutableMapAdaptor -- 从现有的 immutable.Map 实现 mutable.Map 的类。 mutable.LinkedHashMap -- ? mutable.ListMap -- 通过列表实现 mutable.Map 的类。 mutable.MultiMap -- 一个类，每个键接受多个不同的值。 mutable.ObservableMap -- 一个 mixin，当与 Map 混合时，通过 Publisher 接口向观察者发布事件。 mutable.OpenHashMap -- 基于开放散列算法的类。 mutable.SynchronizedMap -- 一个 mixin，它应该与 Map 混合以提供一个带有同步方法的版本。可变的.MapProxy。

mutable.HashMap -- 通过键散列实现 mutable.Map 的类。

mutable.ImmutableMapAdaptor -- 从现有的 immutable.Map 实现 mutable.Map 的类。

mutable.LinkedHashMap -- ?

mutable.ListMap -- 通过列表实现 mutable.Map 的类。

mutable.MultiMap -- 一个类，每个键接受多个不同的值。

mutable.ObservableMap -- 一个 mixin，当与 Map 混合时，通过 Publisher 接口向观察者发布事件。

mutable.OpenHashMap -- 基于开放散列算法的类。

mutable.SynchronizedMap -- 一个 mixin，它应该与 Map 混合以提供一个带有同步方法的版本。

可变的.MapProxy。

序列

Seq——元素的序列。一种假设是明确定义的大小和元素重复。也扩展了 PartialFunction。 IndexedSeq -- 支持 O(1) 元素访问和 O(1) 长度计算的序列。 IndexedSeqView immutable.PagedSeq -- IndexedSeq 的实现，其中元素由通过构造函数传递的函数按需生成。 immutable.IndexedSeq immutable.Range -- 一个分隔的整数序列，在低端关闭，在高端打开，并带有一个步骤。 immutable.Range.Inclusive -- 一个范围也在高端关闭。 immutable.Range.ByOne -- 步长为 1 的 Range。 immutable.NumericRange -- Range 的更通用版本，适用于任何 Integral。不可变.NumericRange.Inclusive，不可变.NumericRange.Exclusive。 immutable.WrappedString, immutable.RichString -- 允许将字符串视为 Seq[Char] 的包装器，同时仍保留字符串方法。我不确定它们之间有什么区别。 mutable.IndexedSeq mutable.GenericArray -- 基于 Seq 的类数组结构。注意，“类”Array是Java的Array，与其说是类，不如说是一种内存存储方式。 mutable.ResizableArray -- 基于可调整大小数组的类使用的内部类。 mutable.PriorityQueue, mutable.SynchronizedPriorityQueue -- 实现优先队列的类 -- 元素根据 Ordering 首先出列的队列，最后排队的顺序。 mutable.PriorityQueueProxy -- PriorityQueue 的抽象代理。 LinearSeq——线性序列的特征，对isEmpty、head和tail有有效的时间。 immutable.LinearSeq immutable.List -- 一个不可变的、单链接的列表实现。 immutable.Stream -- 一个惰性列表。它的元素仅按需计算，但随后被记忆（保存在内存中）。它理论上可以是无限的。 mutable.LinearSeq mutable.DoublyLinkedList -- 具有可变 prev、head (elem) 和 tail (next) 的列表。 mutable.LinkedList -- 具有可变头部（elem）和尾部（下一个）的列表。 mutable.MutableList -- 内部用于实现基于可变列表的类的类。 mutable.Queue, mutable.QueueProxy -- 针对 FIFO（先进先出）操作优化的数据结构。 mutable.QueueProxy -- mutable.Queue 的代理。 SeqProxy、SeqView、SeqForwarder immutable.Seq immutable.Queue -- 实现 FIFO 优化（先进先出）数据结构的类。可变队列和不可变队列没有共同的超类。 immutable.Stack -- 实现 LIFO 优化（后进先出）数据结构的类。两个可变不可变堆栈没有共同的超类。不可变的。向量——？ scala.xml.NodeSeq -- 扩展 immutable.Seq 的专用 XML 类。 immutable.IndexedSeq——如上所示。 immutable.LinearSeq——如上所示。 mutable.ArrayStack -- 使用数组实现 LIFO 优化数据结构的类。据说比普通堆栈快得多。 mutable.Stack, mutable.SynchronizedStack -- 实现 LIFO 优化数据结构的类。 mutable.StackProxy -- mutable.Stack.. mutable.Seq mutable.Buffer 的代理 -- 可以通过追加、前置或插入新成员来更改的元素序列。 mutable.ArrayBuffer -- mutable.Buffer 类的一个实现，具有用于追加、更新和随机访问操作的恒定摊销时间。它有一些专门的子类，例如 NodeBuffer。 mutable.BufferProxy，mutable.SynchronizedBuffer。 mutable.ListBuffer -- 由列表支持的缓冲区。它提供恒定时间追加和前置，大多数其他操作是线性的。 mutable.ObservableBuffer -- 一种混合特征，当它混合到 Buffer 时，通过 Publisher 接口提供通知事件。 mutable.IndexedSeq——如上所示。 mutable.LinearSeq——如上所示。

IndexedSeq -- 支持 O(1) 元素访问和 O(1) 长度计算的序列。 IndexedSeqView immutable.PagedSeq -- IndexedSeq 的实现，其中元素由通过构造函数传递的函数按需生成。 immutable.IndexedSeq immutable.Range -- 一个分隔的整数序列，在低端关闭，在高端打开，并带有一个步骤。 immutable.Range.Inclusive -- 一个范围也在高端关闭。 immutable.Range.ByOne -- 步长为 1 的 Range。 immutable.NumericRange -- Range 的更通用版本，适用于任何 Integral。不可变.NumericRange.Inclusive，不可变.NumericRange.Exclusive。 immutable.WrappedString, immutable.RichString -- 允许将字符串视为 Seq[Char] 的包装器，同时仍保留字符串方法。我不确定它们之间有什么区别。 mutable.IndexedSeq mutable.GenericArray -- 基于 Seq 的类数组结构。注意，“类”Array是Java的Array，与其说是类，不如说是一种内存存储方式。 mutable.ResizableArray -- 基于可调整大小数组的类使用的内部类。 mutable.PriorityQueue, mutable.SynchronizedPriorityQueue -- 实现优先队列的类 -- 元素根据 Ordering 首先出列的队列，最后排队的顺序。 mutable.PriorityQueueProxy -- PriorityQueue 的抽象代理。

索引序列视图

immutable.PagedSeq -- IndexedSeq 的实现，其中元素由通过构造函数传递的函数按需生成。

immutable.IndexedSeq immutable.Range -- 一个分隔的整数序列，在低端关闭，在高端打开，并带有一个步骤。 immutable.Range.Inclusive -- 一个范围也在高端关闭。 immutable.Range.ByOne -- 步长为 1 的 Range。 immutable.NumericRange -- Range 的更通用版本，适用于任何 Integral。不可变.NumericRange.Inclusive，不可变.NumericRange.Exclusive。 immutable.WrappedString, immutable.RichString -- 允许将字符串视为 Seq[Char] 的包装器，同时仍保留字符串方法。我不确定它们之间有什么区别。

immutable.Range -- 一个定界的整数序列，在低端关闭，在高端打开，并带有一个台阶。 immutable.Range.Inclusive -- 一个范围也在高端关闭。 immutable.Range.ByOne -- 步长为 1 的 Range。

immutable.Range.Inclusive -- 一个范围也在高端关闭。

immutable.Range.ByOne -- 步长为 1 的 Range。

immutable.NumericRange -- Range 的更通用版本，适用于任何 Integral。不可变.NumericRange.Inclusive，不可变.NumericRange.Exclusive。 immutable.WrappedString, immutable.RichString -- 允许将字符串视为 Seq[Char] 的包装器，同时仍保留字符串方法。我不确定它们之间有什么区别。

不可变.NumericRange.Inclusive，不可变.NumericRange.Exclusive。

immutable.WrappedString, immutable.RichString -- 允许将字符串视为 Seq[Char] 的包装器，同时仍保留字符串方法。我不确定它们之间有什么区别。

mutable.IndexedSeq mutable.GenericArray -- 基于 Seq 的类数组结构。注意，“类”Array是Java的Array，与其说是类，不如说是一种内存存储方式。 mutable.ResizableArray -- 基于可调整大小数组的类使用的内部类。 mutable.PriorityQueue, mutable.SynchronizedPriorityQueue -- 实现优先队列的类 -- 元素根据 Ordering 首先出列的队列，最后排队的顺序。 mutable.PriorityQueueProxy -- PriorityQueue 的抽象代理。

mutable.GenericArray -- 基于 Seq 的类数组结构。注意，“类”Array是Java的Array，与其说是类，不如说是一种内存存储方式。

mutable.ResizableArray -- 基于可调整大小数组的类使用的内部类。

mutable.PriorityQueue, mutable.SynchronizedPriorityQueue -- 实现优先队列的类 -- 元素根据 Ordering 首先出列的队列，最后排队的顺序。

mutable.PriorityQueueProxy -- PriorityQueue 的抽象代理。

LinearSeq——线性序列的特征，对isEmpty、head和tail有有效的时间。 immutable.LinearSeq immutable.List -- 一个不可变的、单链接的列表实现。 immutable.Stream -- 一个惰性列表。它的元素仅按需计算，但随后被记忆（保存在内存中）。它理论上可以是无限的。 mutable.LinearSeq mutable.DoublyLinkedList -- 具有可变 prev、head (elem) 和 tail (next) 的列表。 mutable.LinkedList -- 具有可变头部（elem）和尾部（下一个）的列表。 mutable.MutableList -- 内部用于实现基于可变列表的类的类。 mutable.Queue, mutable.QueueProxy -- 针对 FIFO（先进先出）操作优化的数据结构。 mutable.QueueProxy -- mutable.Queue 的代理。

immutable.LinearSeq immutable.List -- 一个不可变的、单链接的列表实现。 immutable.Stream -- 一个惰性列表。它的元素仅按需计算，但随后被记忆（保存在内存中）。它理论上可以是无限的。

immutable.List -- 一个不可变的、单链接的列表实现。

immutable.Stream -- 一个惰性列表。它的元素仅按需计算，但随后被记忆（保存在内存中）。它理论上可以是无限的。

mutable.LinearSeq mutable.DoublyLinkedList -- 具有可变 prev、head (elem) 和 tail (next) 的列表。 mutable.LinkedList -- 具有可变头部（elem）和尾部（下一个）的列表。 mutable.MutableList -- 内部用于实现基于可变列表的类的类。 mutable.Queue, mutable.QueueProxy -- 针对 FIFO（先进先出）操作优化的数据结构。 mutable.QueueProxy -- mutable.Queue 的代理。

mutable.DoublyLinkedList -- 具有可变 prev、head (elem) 和 tail (next) 的列表。

mutable.LinkedList -- 具有可变头部（elem）和尾部（下一个）的列表。

mutable.MutableList -- 内部用于实现基于可变列表的类的类。 mutable.Queue, mutable.QueueProxy -- 针对 FIFO（先进先出）操作优化的数据结构。 mutable.QueueProxy -- mutable.Queue 的代理。

mutable.Queue, mutable.QueueProxy -- 针对 FIFO（先进先出）操作优化的数据结构。

mutable.QueueProxy -- mutable.Queue 的代理。

SeqProxy、SeqView、SeqForwarder

immutable.Seq immutable.Queue -- 实现 FIFO 优化（先进先出）数据结构的类。可变队列和不可变队列没有共同的超类。 immutable.Stack -- 实现 LIFO 优化（后进先出）数据结构的类。两个可变不可变堆栈没有共同的超类。不可变的。向量——？ scala.xml.NodeSeq -- 扩展 immutable.Seq 的专用 XML 类。 immutable.IndexedSeq——如上所示。 immutable.LinearSeq——如上所示。

immutable.Queue -- 实现 FIFO 优化（先进先出）数据结构的类。可变队列和不可变队列没有共同的超类。

immutable.Stack -- 实现 LIFO 优化（后进先出）数据结构的类。两个可变不可变堆栈没有共同的超类。

不可变的。向量——？

scala.xml.NodeSeq -- 扩展 immutable.Seq 的专用 XML 类。

immutable.IndexedSeq——如上所示。

immutable.LinearSeq——如上所示。

mutable.ArrayStack -- 使用数组实现 LIFO 优化数据结构的类。据说比普通堆栈快得多。

mutable.Stack, mutable.SynchronizedStack -- 实现 LIFO 优化数据结构的类。

mutable.StackProxy -- mutable.Stack 的代理..

mutable.Seq mutable.Buffer -- 可以通过追加、前置或插入新成员来更改的元素序列。 mutable.ArrayBuffer -- mutable.Buffer 类的一个实现，具有用于追加、更新和随机访问操作的恒定摊销时间。它有一些专门的子类，例如 NodeBuffer。 mutable.BufferProxy，mutable.SynchronizedBuffer。 mutable.ListBuffer -- 由列表支持的缓冲区。它提供恒定时间追加和前置，大多数其他操作是线性的。 mutable.ObservableBuffer -- 一种混合特征，当它混合到 Buffer 时，通过 Publisher 接口提供通知事件。 mutable.IndexedSeq——如上所示。 mutable.LinearSeq——如上所示。

mutable.Buffer -- 可以通过追加、前置或插入新成员来更改的元素序列。 mutable.ArrayBuffer -- mutable.Buffer 类的一个实现，具有用于追加、更新和随机访问操作的恒定摊销时间。它有一些专门的子类，例如 NodeBuffer。 mutable.BufferProxy，mutable.SynchronizedBuffer。 mutable.ListBuffer -- 由列表支持的缓冲区。它提供恒定时间追加和前置，大多数其他操作是线性的。 mutable.ObservableBuffer -- 一种混合特征，当它混合到 Buffer 时，通过 Publisher 接口提供通知事件。 mutable.IndexedSeq——如上所示。 mutable.LinearSeq——如上所示。

mutable.ArrayBuffer -- mutable.Buffer 类的一个实现，具有用于追加、更新和随机访问操作的恒定摊销时间。它有一些专门的子类，例如 NodeBuffer。

mutable.BufferProxy，mutable.SynchronizedBuffer。

mutable.ListBuffer -- 由列表支持的缓冲区。它提供恒定时间追加和前置，大多数其他操作是线性的。

mutable.ObservableBuffer -- 一种混合特征，当它混合到 Buffer 时，通过 Publisher 接口提供通知事件。

mutable.IndexedSeq——如上所示。

mutable.LinearSeq——如上所示。

套装

集合——集合是一个集合，最多包含任何对象中的一个。 BitSet -- 存储为 bitset 的一组整数。 immutable.BitSet mutable.BitSet SortedSet -- 一个集合，其元素是有序的。 immutable.SortedSet immutable.TreeSet -- 基于树的 SortedSet 实现。 SetProxy -- 一个集合的代理。 immutable.Set immutable.HashSet -- 基于元素散列的 Set 实现。 immutable.ListSet -- 基于列表的 Set 实现。存在额外的集合类来为从 0 到 4 个元素的集合提供优化的实现。 immutable.SetProxy -- 不可变集合的代理。 mutable.Set mutable.HashSet -- 基于元素散列的 Set 实现。 mutable.ImmutableSetAdaptor -- 一个从不可变集实现可变集的类。 LinkedHashSet -- 基于列表的 Set 实现。 ObservableSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。 SetProxy -- 一个集合的代理。 SynchronizedSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。

BitSet -- 存储为 bitset 的一组整数。不可变的.BitSet 可变的.BitSet

不可变的.BitSet

可变的.BitSet

SortedSet -- 一个集合，其元素是有序的。 immutable.SortedSet immutable.TreeSet -- 基于树的 SortedSet 实现。

immutable.SortedSet immutable.TreeSet -- 基于树的 SortedSet 实现。

immutable.TreeSet -- 基于树的 SortedSet 的实现。

SetProxy -- 一个集合的代理。

immutable.Set immutable.HashSet -- 基于元素散列的 Set 实现。 immutable.ListSet -- 基于列表的 Set 实现。存在额外的集合类来为从 0 到 4 个元素的集合提供优化的实现。 immutable.SetProxy -- 不可变集合的代理。

immutable.HashSet -- 基于元素散列的 Set 实现。

immutable.ListSet -- 基于列表的 Set 实现。

存在额外的集合类来为从 0 到 4 个元素的集合提供优化的实现。

immutable.SetProxy -- 不可变集合的代理。

mutable.Set mutable.HashSet -- 基于元素散列的 Set 实现。 mutable.ImmutableSetAdaptor -- 一个从不可变集实现可变集的类。 LinkedHashSet -- 基于列表的 Set 实现。 ObservableSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。 SetProxy -- 一个集合的代理。 SynchronizedSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。

mutable.HashSet -- 基于元素散列的 Set 实现。

mutable.ImmutableSetAdaptor -- 一个从不可变集实现可变集的类。

LinkedHashSet -- 基于列表的 Set 实现。

ObservableSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。

SetProxy -- 一个集合的代理。

SynchronizedSet -- 一种混合特征，当与 Set 混合时，通过 Publisher 接口提供通知事件。

为什么存在 Like 类（例如 TraversableLike）

这样做是为了实现最大的代码重用。具有特定结构（可遍历、映射等）的类的具体通用实现在 Like 类中完成。然后，用于一般消费的类会覆盖可以优化的选定方法。

伴随方法的用途（例如 List.companion）

类的构建器，即知道如何创建该类的实例的对象，该对象可以由类似 map 的方法使用，由伴随对象中的方法创建。因此，为了构建类型 X 的对象，我需要从 X 的伴随对象中获取该构建器。不幸的是，在 Scala 中，无法从类 X 中获取对象 X。因此，有在 X 的每个实例中定义的方法 companion，它返回类 X 的伴随对象。

虽然这种方法在普通程序中可能会有一些用途，但它的目标是在集合库中启用代码重用。

我如何知道在给定点的范围内有哪些隐式对象

你不应该关心这个。它们是隐含的，因此您无需弄清楚如何使其工作。

存在这些隐式以使集合上的方法能够在父类上定义，但仍返回相同类型的集合。例如，map 方法是在 TraversableLike 上定义的，但如果您在 List 上使用，则会返回 List。

---