Scala系列8：函数式编程之map，flatten,flatmap的使用详解

我会带着你远行 2022-12-03 08:42 257阅读 0赞

## 0.Scala函数式编程 ##

**我们将来使用Spark/Flink的大量业务代码都会使用到函数式编程。下面这些事开发中常用的函数式编程。注意这些函数都是操作 Scala 集合的，一般会进行两类操作：转换操作（transformation ）和行动操作（actions）（有些人喜欢叫他为聚合操作）。第一种操作类型将集合转换为另一个集合，第二种操作类型返回某些类型的值。**

1.  **遍历（ foreach ）**
2.  **映射（ map ）**
3.  **映射扁平化（ flatmap ）**
4.  **过滤（ filter ）**
5.  **是否存在（ exists ）**
6.  **排序（ sorted 、 sortBy 、 sortWith ）**
7.  **分组（ groupBy ）**
8.  **聚合计算（ reduce ）**
9.  **折叠（ fold ）**

## 1.map的使用详解 ##

集合的映射操作是将来在编写Spark/Flink用得最多的操作，是我们必须要掌握的掌握。**map方法接收一个函数，将这个函数应用到每一个元素，返回一个新的列表**

**【1.1语法结构】**

def map[B](f: (A) ⇒ B): TraversableOnce[B]

**【1.2语法解释】**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70][]

***尖叫提示：***

*  **1.同foreach一样，map传入的参数也是函数，匿名函数**
 *  **2.map 函数的逻辑是遍历集合中的元素并对每个元素调用函数。你也可以不调用任何函数，保持返回元素本身，但这样 map无法发挥作用，因为你在映射过后得到的是同样的集合。**
 *  **3.foreach返回值是Unit，而map返回值是集合，简单来说map就是对集合元素进行加工，不影响集合结构。**
 *  **4.map和foreach，以及后续其他的集合函数一样，都支持类型推定和用下划线\_简化函数定义。**

**【1.3 map使用演示】**

//基础演示
    val chars = Seq('a', 'b', 'c', 'd') 
    chars.map(ch => ch.toUpper) //输出为List(A, B, C, D)
    scala> val numbers = Seq(3, 7, 2, 9, 6, 5, 1, 4, 2)
    numbers: Seq[Int] = List(3, 7, 2, 9, 6, 5, 1, 4, 2)
    scala> numbers.map(x=>x*x)
    res4: Seq[Int] = List(9, 49, 4, 81, 36, 25, 1, 16, 4)
    
    //注意这里打印x，最终返回的也是一个集合，只是空集合，空列表，列表结构不变
    scala> numbers.map(x=>println(x))  
    3
    7
    2
    9
    6
    5
    1
    4
    2
    res5: Seq[Unit] = List((), (), (), (), (), (), (), (), ())
    
    //标准函数，类型推定，下划线替代
    scala> a.map((x:Int)=>x+1)
    res8: List[Int] = List(2, 3, 4, 5)
    
    scala> val a = List(1,2,3,4)
    a: List[Int] = List(1, 2, 3, 4)
    
    scala> a.map(_+1)
    res6: List[Int] = List(2, 3, 4, 5)
    
    scala> a.map(x=>x+1)
    res7: List[Int] = List(2, 3, 4, 5)

## 2.flatten的使用详解 ##

**     flatten可以把嵌套的结构展开。当有一个集合的集合，然后你想对这些集合的所有元素进行操作时，就会用到 flatten。如果一个集合里存放的是元组，则没法压平，只能压平集合。flatten比较简单，没有参数。用的多是跟他名字很像的flatmap。**

val abcd = List('a', 'b', 'c', 'd')
      val efgj = List('e', 'f', 'g', 'h')
      val ijkl = List('i', 'j', 'k', 'l')
      val mnop = List('m', 'n', 'o', 'p')
      val qrst = List('q', 'r', 's', 't')
      val uvwx = List('u', 'v', 'w', 'x')
      val yz   = List('y', 'z')
      val alphabet = Seq(abcd, efgj, ijkl, mnop, qrst, uvwx, yz)
      println(alphabet.flatten)
      //结果：// ArrayBuffer(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
    
    
    //必须是集合的集合才能flatte，同时里面的集合不能是元组，否则也无法flatten。
    scala>  val abc = List((1,2),(3,4))
    abc: List[(Int, Int)] = List((1,2), (3,4))
    
    scala> abc.flatten
    <console>:13: error: No implicit view available from (Int, Int) => scala.collection.GenTraversableOnce[B].
           abc.flatten
               ^
    
    scala> val abc= List(1,2,3)
    abc: List[Int] = List(1, 2, 3)
    
    scala> abc.flatten
    <console>:13: error: No implicit view available from Int => scala.collection.GenTraversableOnce[B].
           abc.flatten
               ^

## 3.flatMap的使用详解 ##

flatMap结合了map和flatten的功能。接收一个可以处理嵌套列表的函数，然后把返回结果连接起来。可以把**flatMap**，理解为先map，然后再flatten

**【3.1语法结构】**

def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70 1][]

**flatMap使用流程**：**如下，对List内部成员先进行map，map的结果为一个返回，然后在返回的新List结果上进行flatten扁平化。简单理解就是flatmap可以拆分成map+flatten**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70 2][]*** 【尖叫提示】***

*  **1.因为flatMap有flatten的操作所以****flatMap****的调用对象必须是集合的集合，要满足flatten的要求**
 *  **2.****flatMap****实际操作中就是可以转化成map函数+flatten函数一起操作，只是前者代码更加简洁**

//1.使用map+flat
    scala>   val fm  = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
    fm: List[String] = List(hadoop hive spark flink flume, kudu hbase sqoop storm)
    
    scala>  fm.map(x => x.split(" "))
    res14: List[Array[String]] = List(Array(hadoop, hive, spark, flink, flume), Array(kudu, hbase, sqoop, storm))
    
    scala> res14.flatten
    res15: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
    scala>  fm.map(x => x.split(" ")).flatten
    res18: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
    
    //2.直接使用flatMap
    scala> fm.flatMap(x => x.split(" "))
    res23: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)
    scala> fm.flatMap(_.split(" "))
    res20: List[String] = List(hadoop, hive, spark, flink, flume, kudu, hbase, sqoop, storm)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70]: /images/20221123/fe0f087af3974639b0656b199db7c268.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70 1]: /images/20221123/ac49e27737124b1e964462c746619362.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2NDQyNTUz_size_16_color_FFFFFF_t_70 2]: /images/20221123/c740e3b627ad4122a4b1586d18b677f9.png