1、函數式編程
介紹：
函數：函數即Function，是從集合A到集合B的一種映射關係。如果集合A中的每一個元素都對應到集合B中的某一個元素，那麼這種映射關係就叫做函數。
我們將來使用Spark/Flink的大量業務代碼都會使用到函數式編程
遍歷 foreach
方法描述： foreach(f: (A) ⇒ Unit): Unit
方法說明：
foreach API 說明 參數 f: (A) ⇒ Unit 接收一個函數對象 ；函數的輸入參數爲集合的元素，返回值爲空 返回值 Unit 空
scala> val list=List(1,2,3,4)
list: List[Int] = List(1, 2, 3, 4)
//定義一個匿名函數傳入到foreach方法中
scala> list.foreach((x:Int)=>println(x))
1
2
3
4
//匿名函數的輸入參數類型可以省略，由編譯器自動推斷
scala> list.foreach(x=>println(x))
1
2
3
4
//當函數參數，只在函數體中出現一次，而且函數體沒有嵌套調用時，可以使用下劃線來簡化函數定 義
scala> list.foreach(println(_))
1
2
3
4
//最簡寫，直接給定println
scala> list.foreach(println)
1
2
3
4
映射- map
方法描述： def map[B](f: (A) ⇒ B): TraversableOnce[B]
方法說明：
map方法 API 說明 泛型 [B] 指定map方法最終返回的集合泛型 參數 f: (A) ⇒ B 傳入一個函數對象；該函數接收一個類型A（要轉換的列表元素），返回值爲類型B 返回值 TraversableOnce[B] B類型的集合
//定義一個list集合，實現把內部每一個元素做乘以10，生成一個新的list集合
scala> val list=List(1,2,3,4)
list: List[Int] = List(1, 2, 3, 4)
//定義一個匿名函數
scala> list.map((x:Int)=>x*10)
res21: List[Int] = List(10, 20, 30, 40)
//省略匿名函數參數類型
scala> list.map(x=>x*10)
res22: List[Int] = List(10, 20, 30, 40)
//最簡寫 用下劃線
scala> list.map(_*10)
res23: List[Int] = List(10, 20, 30, 40)
扁平化映射 - flatmap
方法描述：
def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
方法說明：
flatmap方法 API 說明 泛型 [B] 最終要轉換的集合元素類型 參數 f: (A) ⇒ GenTraversableOnce[B] 傳入一個函數對象 ； 函數的參數是集合的元素，函數的返回值是一個集合 返回值 TraversableOnce[B] B類型的集合
//定義一個List集合,每一個元素中就是一行數據，有很多個單詞
scala> val list = List("hadoop hive spark flink", "hbase spark")
list: List[String] = List(hadoop hive spark flink, hbase spark)
//使用flatMap進行偏平化處理，獲取得到所有的單詞
scala> list.flatMap(x => x.split(" "))
res24: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
//簡寫
scala> list.flatMap(_.split(" "))
res25: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
// flatMap該方法其本質是先進行了map 然後又調用了flatten
scala> list.map(_.split(" ")).flatten
res26: List[String] = List(hadoop, hive, spark, flink, hbase, spark)
過濾 - filter
過濾符合一定條件的元素
方法描述： def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
方法說明：
filter方法 API 說明 參數 p: (A) ⇒ Boolean 傳入一個函數對象 ； 接收一個集合類型的參數，返回布爾類型，滿足條件返回true, 不滿足返回false 返回值 TraversableOnce[A] 列表
//定義一個list集合
scala> val list=List(1,2,3,4,5,6,7,8,9,10)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//過濾出集合中大於5的元素
scala> list.filter(x => x >5)
res27: List[Int] = List(6, 7, 8, 9, 10)
//把集合中大於5的元素取出來乘以10生成一個新的list集合
scala> list.filter(_ > 5).map(_ * 10)
res29: List[Int] = List(60, 70, 80, 90, 100)
排序 -- sort
在scala集合中，可以使用以下幾種方式來進行排序
sorted默認排序
sortBy指定字段排序
方法描述：def sortBy[B](f: (A) ⇒ B): List[A]
方法說明：
sortBy方法 API 說明 泛型 [B] 按照什麼類型來進行排序 參數 f: (A) ⇒ B 傳入函數對象 ；接收一個集合類型的元素參數，返回B類型的元素進行排序 返回值 List[A] 返回排序後的列表
sortWith自定義排序
方法描述： def sortWith(lt: (A, A) ⇒ Boolean): List[A]
方法說明：
sortWith方法 API 說明 參數 lt: (A, A) ⇒ Boolean 傳入一個比較大小的函數對象；接收兩個集合類型的元素參數，返回兩個元素大小，小於返回true，大於返回false 返回值 List[A] 返回排序後的列表
//默認排序
//定義一個List集合
scala> val list=List(5,1,2,4,3)
list: List[Int] = List(5, 1, 2, 4, 3)
//默認就是升序
scala> list.sorted
res30: List[Int] = List(1, 2, 3, 4, 5)
//按照指定字段排序
//定義一個List集合
scala> val list=List("1 hadoop","2 spark","3 flink")
list: List[String] = List(1 hadoop, 2 spark, 3 flink)
//按照單詞的首字母進行排序
scala> list.sortBy(x=>x.split(" ")(1))
res33: List[String] = List(3 flink, 1 hadoop, 2 spark)
//自定義排序
scala> val list = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
//降序
scala> list.sortWith((x,y)=>x>y)
res35: List[Int] = List(6, 5, 4, 3, 2, 1)
//升序
scala> list.sortWith((x,y)=>x<y)
res36: List[Int] = List(1, 2, 3, 4, 5, 6)
分組 -- groupBy
作用：按照函數將列表分成不同的組
方法描述：def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
方法說明：
groupBy方法 API 說明 泛型 [K] 分組字段的類型 參數 f: (A) ⇒ K 傳入一個函數對象 ； 接收集合元素類型的參數，返回一個K類型的key，這個key會用來進行分組，相同的key放在一組中 返回值 Map[K, List[A]] 返回一個映射，K爲分組字段，List爲這個分組字段對應的一組數據
scala> val a = List("張三"->"男", "李四"->"女", "王五"->"男")
a: List[(String, String)] = List((張三,男), (李四,女), (王五,男))
// 按照性別分組
scala> a.groupBy(_._2)
res0: scala.collection.immutable.Map[String,List[(String, String)]] = Map(男 -> List((張三,男), (王五,男)),
女 -> List((李四,女)))
聚合 reduce
作用：將列表傳入一個函數進行聚合操作
方法描述：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
方法說明：
reduce方法 API 說明 泛型 [A1 >: A] （下界）A1必須是集合元素類型的子類 參數 op: (A1, A1) ⇒ A1 傳入函數對象，用來不斷進行聚合操作<br />第一個A1類型參數爲：當前聚合後的變量<br />第二個A1類型參數爲：當前要進行聚合的元素 返回值 A1 列表最終聚合爲一個元素
scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> a.reduce((x,y) => x + y)
res5: Int = 55
// 第一個下劃線表示第一個參數，就是歷史的聚合數據結果
// 第二個下劃線表示第二個參數，就是當前要聚合的數據元素
scala> a.reduce(_ + _)
res53: Int = 55
// 與reduce一樣，從左往右計算
scala> a.reduceLeft(_ + _)
res0: Int = 55
// 從右往左聚合計算
scala> a.reduceRight(_ + _)
res1: Int = 55
摺疊 fold
介紹：fold與reduce很像，但是多了一個指定初始值參數
方法描述：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
方法說明：
reduce方法 API 說明 泛型 [A1 >: A] （下界）A1必須是集合元素類型的子類 參數1 z: A1 初始值 參數2 op: (A1, A1) ⇒ A1 傳入函數對象，用來不斷進行摺疊操作<br />第一個A1類型參數爲：當前摺疊後的變量<br />第二個A1類型參數爲：當前要進行摺疊的元素 返回值 A1 列表最終摺疊爲一個元素
//定義一個List集合
scala> val a = List(1,2,3,4,5,6,7,8,9,10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//求和
scala> a.sum
res41: Int = 55
//給定一個初始值，，摺疊求和
scala> a.fold(0)(_+_)
res42: Int = 55
scala> a.fold(10)(_+_)
res43: Int = 65
//從左往右
scala> a.foldLeft(10)(_+_)
res44: Int = 65
//從右往左
scala> a.foldRight(10)(_+_)
res45: Int = 65
//fold和foldLet效果一致，表示從左往右計算
//foldRight表示從右往左計算