Scala 函数之map(返回集合)、reduce、flatMap、zip和foreach(无返回值)学习

map和flatMap的区别

object collection_t1 {

  def flatMap1(): Unit = {
    val li = List(1,2,3)
    val res = li.flatMap(x => x match {
      case 3 => List('a','b')
      case _ => List(x*2)
    })
    println(res)
  }

  def map1(): Unit = {
    val li = List(1,2,3)
    val res = li.map(x => x match {
      case 3 => List('a','b')
      case _ => x*2
    })
    println(res)
  }

  def main(args: Array[String]): Unit = {
    flatMap1()
    map1()
  }
}

输出结果

List(2, 4, a, b)
List(2, 4, List(a, b))

map

val v = Vector(1, 2, 3, 4)
val v2 = v.map(n => n + 1)

它的输出是

v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4)
v2: scala.collection.immutable.Vector[Int] = Vector(2, 3, 4, 5)

什么意思呢？

第一句的意思是声明一个向量名叫v，并将初始值传递给它，用Java程序猿习惯的说法是创建一个向量对象，赋给v。

第二句话的意思是对v的每个元素加1，产生新的向量返回给v2。从输出中可以看出结果确实如此。

map这个单词在这里不是地图的意思，而是映射、关联，将源容器中的元素经过函数处理后一一映射到新容器中。上面代码中执行的函数就是加个1的匿名函数，我们可以自己定义成其他函数，加2啊，乘5啊，平方啊，等等。

reduce

reduce返回的值的类型必须和列表的元素类型相关。

val v = Vector(1, 2, 3, 4)
val v3 = v.reduce((sum, n) => sum + n)

它的输出是

v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4)
v3: Int = 10

这个10是怎么来的呢，或者说reduce是干嘛用的那？

reduce也不是减少的意思，而是归纳、简化的意思，具体讲是把容器中的元素作参数传给里面的二元匿名函数，我的理解是实际上是个尾递归函数。不要被这个名词吓到，它只是把递归换了个形式，等价的Java代码如下：

 public static int sumInt(int n) {
        return sumInt(1, n );
    }

    public static int sumInt(int lastResult, int n) {
        if (n <= 1) return lastResult;
        return sumInt(n + lastResult, n - 1);
    }

总之就是自己调用自己，之所以换种形式，是因为尾递归更容易优化，效率更高，内存占用更少。

回过头来看reduce就是这种用尾递归的方式处理二元匿名函数，函数体可以是求和，也可以是求积，等等，把容器中的元素归集起来返回。

flatMap

通过 flatMap 我们可以处理元素是序列的列表。将提供的函数应用于每个序列元素会返回包含原始列表所有序列内的元素的列表。

scala> val list3 = 10 to 20 toList
list3: List[Int] = List(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> val list2 = 1 to 10 toList
list2: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> val list4 = List(list2, list3)
list4: List[List[Int]] = List(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), List(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20))

scala> list4.flatMap(x=>x.map(y=>y*2))
res2: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40) 

我们可以看到有list4的元素是两个列表。我们调用 flatMap 分别处理这两个列表，并用 map 将这两个列表的元素平方，最后的结果是一个包含所有元素的平坦的列表。

译者注：flatMap并不一定用于元素是序列的列表，他只需要应用的函数返回的结果是 GenTraversableOnce 即可（列表的父类），例如：

scala> List(1,2,3,4,5)
res0: List[Int] = List(1, 2, 3, 4, 5)

scala> res0.flatMap(x => 1 to x )
res1: List[Int] = List(1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5)

zip

从它的名字就可以知道我们可以用此合并两个列表：

scala> val list = "Hello.World".toCharArray
list: Array[Char] = Array(H, e, l, l, o, ., W, o, r, l, d)

scala> val list1 = 1 to 20 toList
list1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> list.zip(list1)
res30: Array[(Char, Int)] = Array((H,1), (e,2), (l,3), (l,4), (o,5), (.,6), (W,7), (o,8), (r,9), (l,10), (d,11))

scala> list1.zip(list)
res31: List[(Int, Char)] = List((1,H), (2,e), (3,l), (4,l), (5,o), (6,.), (7,W), (8,o), (9,r), (10,l), (11,d))

返回的列表长度取决于较短的列表，只要有一个列表到达了末尾 zip 函数就停止了。我们可以使用 zipAll 函数来对较长列表的剩余元素进行处理：

scala> list.zipAll(list1,'a','1')
res33: Array[(Char, AnyVal)] = Array((H,1), (e,2), (l,3), (l,4), (o,5), (.,6), (W,7), (o,8), (r,9), (l,10), (d,11), (a,12), (a,13), (a,14), (a,15), (a,16), (a,17), (a,18), (a,19), (a,20))
(译者注：最后一个参数为1，让返回类型是Array[(Char,Int)]对于这个例子更好点)  

如果字母的列表比较短，那么用 'a' 来补充，反之用 '1' 来补充。最后一个要介绍的 zip 函数是 zipWithIndex 。就像他的名字一样，元素的下标（从0开始）会被增加进去：

scala> list.zipWithIndex
res36: Array[(Char, Int)] = Array((H,0), (e,1), (l,2), (l,3), (o,4), (.,5), (W,6), (o,7), (r,8), (l,9), (d,10))  

foreach

val v = Vector(1, 2, 3, 4)
val v4 = v.foreach(n => println(n))

产生的输出是

1
2
3
4
v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4)
v4: Unit = ()

v4类型是Unit，就是空的意思，因为foreach没有返回。