Question

1. Traversable 的所有操作为（xs 是一个 Traversable 对象）：

   • 抽象操作：

     • xs foreach f ：对 xs 的每个元素执行函数 f 。

   • 添加操作：

     • xs ++ ys： 拼接 xs 和 ys 的所有元素， 返回一个新的 Traversable 。ys 是一个 TraversableOnce ，它既可以是一个 Traversable 也可以是一个 Iterator 。

   • 映射操作：

     • xs map f：通过对 xs 的每个元素应用函数 f ，返回一个新的 Traversable 。
     • xs flatmap f：通过对 xs 的每个元素(是一个 Traversable ) 的每个元素应用函数 f ，返回一个新的 Traversble 。
     • xs collect f： 通过对 xs 的每个元素应用偏函数 f ，并将定义的结果收集起来得到的集合。

   • 转化操作：

     • xs.toArray ： 将 Traversable 转换成Array 。
     • xs.toList： 将 Traversable 转换为 List 。
     • xs.toIterable： 将 Traversable 转换为 Iterable。
     • xs.toSeq： 将 Traversable 转换为 Seq 。
     • xs.toIndexedSeq ： 将 Traversable 转换成IndexedSeq 。
     • xs.toStream ： 将 Traversable 转换成Stream 。
     • xs.toSet ： 将 Traversable 转换成Set 。
     • xs.toMap ： 将 Traversable 转换成Map 。

   • 拷贝操作：

     • xs.copyToBuffer(buf)： 将 xs 的所有元素拷贝到缓冲 buf 中。
     • xs.copyToArray(arr,s,len)： 将 xs 的从下标 s 开始的、最多 len 个元素拷贝到 arr 中 。 s 和 len 是可选的， 默认从0 开始， 拷贝长度为 xs 大小。

   • 大小信息：

     • xs.isEmpty： 测试 xs 是否为空。
     • xs.nonEmpty： 测试 xs 是否非空。
     • xs.size： 返回 xs 的元素数量。
     • xs.hasDefiniteSize： 如果 xs 的大小有限， 则返回 true。

   • 获取元素：

     • xs.head： 获取第一个元素(如果是有序的集合)， 或者某个元素(如果是无序的集合)。
     • xs.headOption： 获取第一个元素或者某个元素， 如果 xs 为空时返回 None。
     • xs.last： 获取最后一个元素(如果是有序的集合)， 或者某个元素(如果是无序的集合)。
     • xs.lastOption：获取最后一个元素或者某个元素， 如果 xs 为空时返回 None。
     • xs find p：返回xs 中满足 p 的首个元素，当 xs 为空时返回 None 。

   • 子集：

     • xs.tail： 集合去掉 xs.head 的部分。
     • xs.init： 集合去掉 xs.last 的部分。
     • xs.slice(from,to)：集合位于from (包含)到 to (不包含)区间的元素组合的新集合。
     • xs.take(n)： 包含集合xs 的前 n 个元素(如果是有序的集合)， 或者任意 n 个元素(如果是无序的集合)。
     • xs.drop(n)： 集合去掉 xs.take(n) 的部分。
     • xs.takeWhile(p)： 寻求满足 p 条件为true 的第一个元素， 假设其索引为n， 则返回 xs.take(n)。
     • xs.dropWhile(p)： 寻求满足 p 条件为true 的第一个元素， 假设其索引为n， 则返回 xs.drop(n) 。
     • xs.filter(p)： 包含xs 中所有满足条件p 的元素。
     • xs.withFilter(p)： xs.filter(p) 的延迟版本。它不生成新的集合， 而是一个 WithFilter 对象， 它主要用于 map/flatMap/foreach/withFilter 等链式操作， 在后续操作才生成新的集合， 从而提高性能。
     • xs.filterNot(p)： 包含xs 中所有不满足条件p 的元素。

   • 拆分：

     • xs.splitAt(n)： 在指定位置拆分 xs ，返回一对集合 (xs.take(n), xs.drop(n)) 。
     • xs.span(p)： 根据条件 p 切分xs， 返回一对集合 (xs.takeWhile(p), xs.dropWhile(p))。
     • xs.partition(p)： 根据条件p 分离 xs， 返回一对集合 (xs.filter(p), xs.filterNot(p))。
     • xs.groubBy(f)： 根据分区函数 f 将 xs 转化为各分区到子集合的映射。其中 f 将元素映射为分区的 key 。

   • 元素条件：

     • xs.forall(p)： 是否 xs 的所有元素都满足条件 p 。
     • xs.exists(p)： 是否 xs 存在元素满足条件 p 。
     • xs.count(p)： xs 中满足条件 p 的元素数量。

   • 折叠：

     • (z /: xs)(op) ： 以z 开始从左到右依次对 xs 中的连续元素应用二元操作op 。相比 xs reduceLeft op，这里提供了初始值 z 。
     • (xs :\ z)(op) ： 以 z 开始从右到左依次对 xs 中的连续元素应用二元操作op 。相比 xs reduceRight op，这里提供了初始值 z 。
     • xs.foldLeft(z)(op)： 同(z /: xs)(op) 。
     • xs.foldRight(z)(op)： 同 (xs :\ z)(op) 。
     • xs reduceLeft op： 从左到右依次对非空集合 xs 的连续元素应用二元操作op 。
     • xs reduceRight op： 从右到左依次对非空集合 xs 的连续元素应用二元操作op 。

   • 特殊折叠：

     • xs.sum： 数值集合 xs 中元素的和。
     • xs.product ： 数值集合 xs 中元素的积。
     • xs.min： 有序集合 xs 中元素值的最小值。有序指的是元素之间可以排序，而不是序列已经排好序。
     • xs.max： 有序集合 xs 中元素值的最大值。

   • 字符串：

     • xs addString (b,start,sep,end)： 将一个显示 xs 从 start 到 end 的元素的字符串， 按照 sep 分隔， 添加到 StringBuilder b 中。 start, end, sep 均为可选。
     • xs mkString (start,sep,end)： 返回一个字符串，它包含 xs 从 start 到 end 的元素的字符串， 按照 sep 分隔。 start, end, sep 均为可选。
     • xs.stringPrefix： 返回集合的名称字符串（如 "List" 字符串）。

   • 视图：

     • xs.view ： 产生一个 xs 的视图。
     • xs.view(from，to)： 产生一个代表 xs 中某个下标区间元素的视图。

2. Traversable 特质唯一的抽象操作是 foreach (当然还有其它非抽象操作)：

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

   该方法的本意是遍历集合中的所有元素，并对每个元素应用给定的操作 f 。

   • f 的类型为 Elem => U ，其中 Elem 是集合的元素类型，而 U 是任意的结果类型。
   • 对 f 的调用仅仅是为了副作用，事实上 foreach 会丢弃函数调用 f 的所有结果。

   实现 Traversable 的集合类只需要定义foreach 方法即可。

3. Traversable 特质还定了很多具体方法， 其中包括：

   • ++ ： 将两个 Traversable 加在一起， 或者将某个迭代器的所有元素添加到 Traversable 。

   • 映射操作： map/flatMap/collect 通过对集合元素应用某个函数来产生一个新的集合。

   • 转化： toIndexedSeq/toIterable/toStream/toArray/toList/toSeq/toSet/toMap 将一个 Traversable 转换到更具体的集合。 如果原始的集合已经是目标类型， 则直接返回原始集合。

     例如， 对List 对象调用 .toList 会直接返回它本身。

   • 拷贝： copyToBuffer/copyToArray 分别将元素拷贝到 Buffer 或者 Array

   • 大小操作： isEmpty/nonEmpty/size/hasDefiniteSize 可用于判断集合大小。

     能被遍历的集合可以是有限的， 也可以是无限的。 如表示自然数的流 Stream.from(0) 就是一个无限可遍历集合。此时 hasDefiniteSize 返回 false， 此时 size 方法会报错或者根本不返回。

   • 元素获取： head/last/headOption/lastOption/find 这些操作用于获取元素。 注意： 并非所有的集合都有定义定义好的“第一个” 或者 “最后一个”的语义。

     如果某个集合总是以相同的顺序交出元素，那么它就是有序的 ordered 。 对于有序的集合，它有“第一个” 和“最后一个” 语义。

     大多数集合都是有序的，但是有一些不是， 如HashSet 。Scala 提供了对所有集合类型的有序版本，如 HashSet 的有序版本是 LinkedHashSet 。

   • 子集获取：tail/init/slice/take/takeWhile/drop/dropWhile/filter/filterNot/withFilter 等操作都用于获取子集。

   • 拆分： splitAt/span/partition/groupBy 等操作将集合切分成若干个子集。

   • 元素测试： exists/forall/count 等操作用于使用给定的条件p 来对集合元素进行测试。

   • 折叠： foldLeft、foldRight、 /: 、 :\、 reduceLeft、reduceRight 等操作用于对集合中连续的元素应用某个二元操作。

   • 特定折叠： sum/product/min/max 等操作用于特定类型的集合(如数值类型或可比较类型) 的特定折叠操作 (求和、乘积、最小、最大)。

   • 字符串操作： mkString/addString/stringPrefix 操作用于将集合转换成字符串。

   • 视图操作： view 操作用于构建视图， 其中视图是一个惰性求值的集合。