例項一：

package com.atguigu.scala.chapter07

/**
  * Author: Felix
  * Date: 2020/5/4
  * Desc: 集合計算高階函式
  */
object Scala12_TestFun {
  def main(args: Array[String]): Unit = {
    //val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //（1）過濾 遍歷一個集合並從中獲取滿足指定條件的元素組成一個新的集合
    //對List集合進行遍歷，將偶數取出，放到新的集合中去
    
 
//println(list.filter((elem: Int) => {
    //  elem % 2 == 0
    //}))
    //println(list.filter( _ % 2 == 0))

    //（2）轉化/對映（map） 將集合中的每一個元素對映到某一個函式
    //println(list.map(_ * 2))

    //（3）扁平化   :::
    //val nestedList : List[List[Int]]  = List(List(1,2,3),List(4,5,6),List(7,8,9))
    //val newList: List[Int] = nestedList.flatten
    
 
//newList.foreach(println)

    //（4）扁平化+對映 注：flatMap相當於先進行map操作，在進行flatten操作  集合中的每個元素的子元素對映到某個函式並返回新集合

    //val strings: List[String] = List("hello atguigu","hello jingjing","banzhang jingjing")
    /*
    //對字串使用空格進行分割，將分割後的單詞放到一個新的集合中  List("hello","atguigu","hello","jingjing","banzhang","jingjing")

    //先對集合中的元素進行轉換   字串---->陣列
    val splitList: List[Array[String]] = strings.map(_.split(" "))

    //將集合中的元素由整體 --->個體
    val flatList: List[String] = splitList.flatten

    //輸出檢視效果
    println(flatList)
    
 
*/

    //使用flatMap函式完成上述功能
    //val flatMapList: List[String] = strings.flatMap(_.split(" "))
    //println(flatMapList)

    //（5）分組(groupBy) 按照指定的規則對集合的元素進行分組
    //val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //val groupMap: Map[Int, List[Int]] = list.groupBy(_%2)
    //println(groupMap)

    val nameList: List[String] = List("jingjing","banzhang","banhua","xingda","jiafeng")

    val groupMap: Map[Char, List[String]] = nameList.groupBy(_.charAt(0))
    println(groupMap)



  }
}

例項二：

package com.atguigu.scala.chapter07

/**
  * Author: Felix
  * Date: 2020/5/5
  * Desc:
  *   -簡化|規約
  *     >通過指定的邏輯將集合中的資料進行聚合，從而減少資料，最終獲取結果。
  *     >reduce
  *         底層呼叫的是reduceLedft
  *         函式引數型別必須一致
  *     >reduceLeft    函式引數型別可以不一致
  *     >reduceRight   函式引數型別可以不一致
  *   -摺疊
  *       fold|foldLeft|foldRight
  */
object Scala13_TestFun {
  def main(args: Array[String]): Unit = {
    //val list: List[Int] = List(1,2,3,4)
    //val res: Int = list.reduce((a:Int,b:Int)=>{a+b})
    //val res: Int = list.reduce(_+_)
    //val res: Int = list.reduceLeft(_+_)
    //val res: Int = list.reduceRight(_+_)
    //println(res)

    //println(list.reduceLeft(_ - _))//-8
    //println(list.reduceRight(_ - _))//-2

    val list2: List[Int] = List(3,4,5,8,10)
    //val res: Int = list2.reduceRight(_-_)   //6

    //println(res)

    //摺疊   集合外元素和集合內部元素進行聚合
    //val res: Int = list.fold(10)(_+_)
    //println(res)

    //println(list.foldLeft(10)(_ + _))

    println(list2.foldRight(11)(_ - _))



  }
}

例項三：

package com.atguigu.scala.chapter07

import scala.collection.mutable

/**
  * Author: Felix
  * Date: 2020/5/5
  * Desc: 對兩個map集合之間的資料進行合併
  */
object Scala14_TestFun {
  def main(args: Array[String]): Unit = {

    val map1 = mutable.Map("a"->1, "b"->2, "c"->3)

    val map2 = mutable.Map("a"->4, "b"->5, "d"->6)

    //最終合併後的效果  Map("a"->5,"b"->7,"c"->3,"d"->6)

    //技術選型：兩個集合之間合併不屬於集合內部元素聚合，所以fold更合適有些

    /*
    val res: mutable.Map[String, Int] = map1.foldLeft(map2) {
      //mm表示map2,kv表示map1中的每一個元素
      (mm, kv) => {
        //指定合併規則
        val k: String = kv._1
        val v: Int = kv._2
        //根據map1中元素的key，到map2中獲取value
        mm(k) = mm.getOrElse(k, 0) + v
        mm
      }
    }
    println(res)
*/

    val res: mutable.Map[String, Int] = map2.foldLeft(map1) {
      (mm, kv) => {
        val k: String = kv._1
        val v: Int = kv._2
        mm(k) = mm.getOrElse(k, 0) + v
        mm
      }
    }
    println(res)
  }
}