如果你的编程是不可变的，并且需要随机访问，那么Seq是最好的选择(除非你想要一个Set，实际上你经常这样做)。除此之外，List工作得很好，只是它的操作不能并行化。

如果你不需要不可变的数据结构，坚持使用ArrayBuffer，因为它在Scala中相当于ArrayList。

在涉及大量随机访问和随机突变的情况下，Vector(或者-正如文档所说- Seq)似乎是一个很好的折衷方案。这也是性能特征所暗示的。

此外，Vector类在没有太多数据复制的分布式环境中似乎表现得很好，因为不需要对完整的对象进行写时复制。(参见:http://akka.io/docs/akka/1.1.3/scala/stm.html # persistent-datastructures)

如果你的编程是不可变的，并且需要随机访问，那么Seq是最好的选择(除非你想要一个Set，实际上你经常这样做)。除此之外，List工作得很好，只是它的操作不能并行化。

如果你不需要不可变的数据结构，坚持使用ArrayBuffer，因为它在Scala中相当于ArrayList。

Some of the statements here are confusing or even wrong, especially the idea that immutable.Vector in Scala is anything like an ArrayList. List and Vector are both immutable, persistent (i.e. "cheap to get a modified copy") data structures. There is no reasonable default choice as their might be for mutable data structures, but it rather depends on what your algorithm is doing. List is a singly linked list, while Vector is a base-32 integer trie, i.e. it is a kind of search tree with nodes of degree 32. Using this structure, Vector can provide most common operations reasonably fast, i.e. in O(log_32(n)). That works for prepend, append, update, random access, decomposition in head/tail. Iteration in sequential order is linear. List on the other hand just provides linear iteration and constant time prepend, decomposition in head/tail. Everything else takes in general linear time.

This might look like as if Vector was a good replacement for List in almost all cases, but prepend, decomposition and iteration are often the crucial operations on sequences in a functional program, and the constants of these operations are (much) higher for vector due to its more complicated structure. I made a few measurements, so iteration is about twice as fast for list, prepend is about 100 times faster on lists, decomposition in head/tail is about 10 times faster on lists and generation from a traversable is about 2 times faster for vectors. (This is probably, because Vector can allocate arrays of 32 elements at once when you build it up using a builder instead of prepending or appending elements one by one). Of course all operations that take linear time on lists but effectively constant time on vectors (as random access or append) will be prohibitively slow on large lists.

那么我们应该使用哪种数据结构呢? 基本上有四种常见的情况:

We only need to transform sequences by operations like map, filter, fold etc: basically it does not matter, we should program our algorithm generically and might even benefit from accepting parallel sequences. For sequential operations List is probably a bit faster. But you should benchmark it if you have to optimize. We need a lot of random access and different updates, so we should use vector, list will be prohibitively slow. We operate on lists in a classical functional way, building them by prepending and iterating by recursive decomposition: use list, vector will be slower by a factor 10-100 or more. We have an performance critical algorithm that is basically imperative and does a lot of random access on a list, something like in place quick-sort: use an imperative data structure, e.g. ArrayBuffer, locally and copy your data from and to it.

对于不可变的集合，如果你想要一个序列，你的主要决定是使用IndexedSeq还是LinearSeq，这对性能有不同的保证。IndexedSeq提供了元素的快速随机访问和快速长度操作。线性seq只提供了通过头部对第一个元素的快速访问，但也有一个快速的尾部操作。(摘自Seq文档。)

对于IndexedSeq，您通常会选择Vector。Ranges和WrappedStrings也是IndexedSeqs。

对于LinearSeq，您通常会选择一个列表或其惰性等效流。其他的例子是队列和堆栈。

所以在Java术语中，ArrayList类似于Scala的Vector, LinkedList类似于Scala的List。但在Scala中，我更倾向于使用List而不是Vector，因为Scala对包含序列遍历的函数有更好的支持，比如映射、折叠、迭代等。您将倾向于使用这些函数将列表作为一个整体来操作，而不是随机访问单个元素。

作为一般规则，默认使用Vector。它几乎在所有方面都比List快，而且对于大小大于一般的序列，它的内存效率更高。请参阅此文档，了解Vector与其他集合的相对性能。使用Vector也有一些缺点。具体地说:

头部的更新比List慢(虽然没有你想象的慢)

Scala 2.10之前的另一个缺点是模式匹配支持对List更好，但这在2.10中通过通用的+:和:+提取器得到了纠正。

还有一种更抽象的代数方法来解决这个问题:你在概念上有什么样的序列?还有，你在概念上用它做什么?如果我看到一个返回Option[a]的函数，我知道这个函数在它的域中有一些漏洞(因此是局部的)。我们可以将同样的逻辑应用于集合。

If I have a sequence of type List[A], I am effectively asserting two things. First, my algorithm (and data) is entirely stack-structured. Second, I am asserting that the only things I’m going to do with this collection are full, O(n) traversals. These two really go hand-in-hand. Conversely, if I have something of type Vector[A], the only thing I am asserting is that my data has a well defined order and a finite length. Thus, the assertions are weaker with Vector, and this leads to its greater flexibility.