一.说明：

1.过滤 ：遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

2.映射（map）:将集合中的一个每一个元素映射到某一函数

3.扁平化：将多个List[List[Int]]这样的一个集合打散，变成一个单一的List集合

4.扁平化+映射：：flatMap 相当于先进行 map 操作，在进行 flatten 操作 集合中的每个元素的子元素映射到某个函数并返回新集合

5.分组(group)：按照指定的规则对集合元素进行分组，返回一个Map

6.规约（reduce）:通过指定的逻辑对集合中的数据进行聚合

7.折叠（flod）:化简的另外一种形式

二.

1.

package scala.ssy.Learning.Six

object Test_Func {
  def main(args: Array[String]): Unit = {
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
    val wordList: List[String] = List("hello world", "hello spark", "hello scala")
      //（1）过滤，要满足一定条件
      println(list.filter(x => x % 2 == 0))
      println(list.filter(_%2==0))
      //（2）转化/映射
      println(list.map(x => x + 1))
      println(list.map(_+1))
      //（3）扁平化:打散 List(hello, world, hello, spark, hello, scala)
      println(nestedList.flatten)
      //（4）扁平化+映射 注：flatMap 相当于先进行 map 操作，在进行 flatten操作
      println(wordList.flatMap(x => x.split(" ")))
      println(wordList.flatMap(_.split(" ")))
      //（5）分组 最后得到的是个Map   HashMap(0 -> List(2, 4, 6, 8), 1 -> List(1, 3, 5, 7, 9))
      println(list.groupBy(x => x % 2))
      println(list.groupBy(_%2))
  }
}

 2.Reduce:

package scala.ssy.Learning.Six

object Test_Reduce {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4)
    // 将数据两两结合，实现运算规则
    val i: Int = list.reduce( (x,y) => x-y )
    println("i = " + i)
    // 从源码的角度，reduce 底层调用的其实就是 reduceLeft
    //val i1 = list.reduceLeft((x,y) => x-y)   1-2-3-4
    
    val i2 = list.reduceRight((x,y) => x-y)
    val i3=list.reduceRight(_ - _)// 1-（2-（3-4））
    println(i3)
    println(i2)
  }
}

3.Flod:

    val list = List(1,2,3,4)
    // fold 方法使用了函数柯里化，存在两个参数列表
    // 第一个参数列表为 ： 零值（初始值）
    // 第二个参数列表为： 简化规则
    // fold 底层其实为 foldLeft
    val i = list.foldLeft(1)((x,y)=>x-y)
    // 1是初始的值  1-1-2-3-4
    val i1 = list.foldRight(10)((x,y)=>x-y)
    val i2= list.foldRight(10)(_ - _)
    // 10是初始值 1-(2-(3-(4-10)))
    println(i)
    println(i1)