Scala 课堂:集合(二)
这里我们转载 Twitter 的 Scala 课堂 ，转载的内容基本来自 Twitter 的 Scala 课堂中文翻译，部分有小改动.
函数组合子（Functional Combinators）
List(1, 2, 3) map squared 对列表中的每一个元素都应用了 squared 平方函数，并返回一个新的列表 List(1, 4, 9)。我们称这个操作 map 组合子。 （如果想要更好的定义，你可能会喜欢 Stackoverflow 上对组合子的说明。）他们常被用在标准的数据结构上。
map
map 对列表中的每个元素应用一个函数，返回应用后的元素所组成的列表。
scala> val numbers = List(1, 2, 3, 4)
numbers: List[Int] = List(1, 2, 3, 4)
scala> numbers.map((i: Int) => i * 2)
res9: List[Int] = List(2, 4, 6, 8)
或传入一个部分应用函数
scala> def timesTwo(i: Int): Int = i * 2
timesTwo: (i: Int)Int
scala> numbers.map(timesTwo _)
res10: List[Int] = List(2, 4, 6, 8)
foreach
foreac h很像 map，但没有返回值。foreach 仅用于有副作用[side-effects]的函数。
scala> numbers.foreach((i: Int) => i * 2)
什么也没有返回。 你可以尝试存储返回值，但它会是 Unit 类型（即 void ）
scala> val doubled = numbers.foreach((i: Int) => i * 2)
doubled: Unit = ()
filter
filter 移除任何对传入函数计算结果为 false 的元素。返回一个布尔值的函数通常被称为谓词函数[或判定函数]。
scala> numbers.filter((i: Int) => i % 2 == 0)
res12: List[Int] = List(2, 4)
scala> def isEven(i: Int): Boolean = i % 2 == 0
isEven: (i: Int)Boolean
scala> numbers.filter(isEven _)
res13: List[Int] = List(2, 4)
zip
zip 将两个列表的内容聚合到一个对偶列表中。
scala> List(1, 2, 3).zip(List("a", "b", "c"))
res14: List[(Int, String)] = List((1,a), (2,b), (3,c))
partition
partition 将使用给定的谓词函数分割列表。
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> numbers.partition(_ %2 == 0)
res15: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
find
find 返回集合中第一个匹配谓词函数的元素。
scala> numbers.find((i: Int) => i > 5)
res16: Option[Int] = Some(6)
drop & dropWhile
drop 将删除前 i 个元素
scala> numbers.drop(5)
res17: List[Int] = List(6, 7, 8, 9, 10)
dropWhile 将删除元素直到找到第一个匹配谓词函数的元素。例如，如果我们在 numbers 列表上使用 dropWhile 奇数的函数, 1将被丢弃（但3不会被丢弃，因为他被2“保护”了）。
scala> numbers.dropWhile(_ % 2 != 0)
res18: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)
foldLeft
scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n)
res19: Int = 55
0为初始值（记住 numbers 是 List[Int] 类型），m 作为一个累加器。 直接观察运行过程：
scala> numbers.foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
m: 0 n: 1
m: 1 n: 2
m: 3 n: 3
m: 6 n: 4
m: 10 n: 5
m: 15 n: 6
m: 21 n: 7
m: 28 n: 8
m: 36 n: 9
m: 45 n: 10
res20: Int = 55
foldRight
和 foldLeft 一样，只是运行过程相反。
scala> numbers.foldRight(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
m: 10 n: 0
m: 9 n: 10
m: 8 n: 19
m: 7 n: 27
m: 6 n: 34
m: 5 n: 40
m: 4 n: 45
m: 3 n: 49
m: 2 n: 52
m: 1 n: 54
res21: Int = 55
flatten
flatten 将嵌套结构扁平化为一个层次的集合。
scala> List(List(1, 2), List(3, 4)).flatten
res22: List[Int] = List(1, 2, 3, 4)
flatMap
flatMap 是一种常用的组合子，结合映射[mapping]和扁平化[flattening]。 flatMap 需要一个处理嵌套列表的函数，然后将结果串连起来。
scala> val nestedNumbers = List(List(1, 2), List(3, 4))
nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))
scala> nestedNumbers.flatMap(x => x.map(_ * 2))
res23: List[Int] = List(2, 4, 6, 8)
可以把它看做是“先映射后扁平化”的快捷操作：
scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten
res24: List[Int] = List(2, 4, 6, 8)
扩展函数组合子
现在我们已经学过集合上的一些函数。 我们将尝试写自己的函数组合子。 有趣的是，上面所展示的每一个函数组合子都可以用 fold 方法实现。让我们看一些例子。
scala> def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = {
| numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) =>
| fn(x) :: xs
| }
| }
ourMap: (numbers: List[Int], fn: Int => Int)List[Int]
scala> ourMap(numbers, timesTwo(_))
res25: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
为什么是 List[Int]()？Scala 没有聪明到理解你的目的是将结果积聚在一个空的 Int 类型的列表中。
Map?
所有展示的函数组合子都可以在 Map 上使用。Map 可以被看作是一个二元组的列表，所以你写的函数要处理一个键和值的二元组。
scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201)
extensions: scala.collection.immutable.Map[String,Int] = Map(steve -> 100, bob -> 101, joe -> 201)
现在筛选出电话分机号码低于200的条目。
scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200)
res26: scala.collection.immutable.Map[String,Int] = Map(steve -> 100, bob -> 101)
因为参数是元组，所以你必须使用位置获取器来读取它们的键和值。呃！ 幸运的是，我们其实可以使用模式匹配更优雅地提取键和值。
scala> extensions.filter({case (name, extension) => extension < 200})
res27: scala.collection.immutable.Map[String,Int] = Map(steve -> 100, bob -> 101)