【Scala】函数式编程高级部分

1 作为值的函数

在Scala中，函数是头等公民，就和数一样，可以在变量中存放函数

在Scala中，有一个约定，就是将函数赋值给变量时，必须在函数后面加上空格和下划线

/**
   * 函数可以作为值传递给另一个变量，或者另一个函数，
   * 语法特点：必须要在函数后面加上空格或者下划线
   */
  def funOps1(): Unit ={
    def sayGoodBye(name:String): Unit ={
      println(name)
    }
    
    //传递给变量
    val sayBye = sayGoodBye _
    sayBye("zhangsan")
    
    //传递给函数
    def sayByeBye = sayGoodBye _
    sayByeBye("lisi")
    
  }

2 匿名函数

在scala中，不需要给每一个函数命名

匿名函数的定义称为“Lambda表达式”

/**
   * 匿名函数：没有名字的函数
   * scala中定义一个完整的函数：def name(params):return={body}
   * 匿名函数：(params)=>{body}     匿名函数的实现
   *         (params)=>returnType 匿名函数的定义
   * 如何调用匿名函数？
   *      只有将匿名函数赋值给另外一个函数或变量来调用
   */
  def funOps2: Unit ={
    val sayBye = (name:String)=>{
      println(name)
    }
    def sayByeBye=(name:String)=>{
      println(name)
    }
    sayBye("wuer")
    sayByeBye("liuer")
  }

3 高阶函数

 /**
   * 高阶函数：
   *    带函数参数的函数，一个函数的参数是函数，这种函数为高阶函数
   */
  def funOps3: Unit ={
    //定义一个高阶函数
    def sayBye(name:String,func:(String)=>Unit): Unit ={
      func(name)
    }
    
    //调用函数sayBye
    sayBye("lisi1",(name:String)=>method(name))
    //传递匿名函数
    sayBye("zhaoliu",(name:String)=>println(name))
    
    //简化书写，如果匿名函数中只有一个变量，可以省略（）
    sayBye("wuer",name=>println(name))
    //可以使用通配符"_"代替变量
    sayBye("lisi3",println(_))
    //最简形式
    sayBye("lisi4",println)
    sayBye("lisi5",method)

  }

  def method(str:String): Unit ={
    println(str)
  }

4 常见函数

4.1 filter

 /**
   * filter:过滤
   * filter:(A=>Boolean)
   * 过滤掉集合中的元素A，经过函数操作返回值为false的元素
   */
  def filterOps(): Unit ={
    //过滤掉集合中的偶数
    val array = 1 to 10
    val array1 = array.filter((num:Int) => ( num%2 != 0))
    
    //化简
    val array2 = array.filter(_ % 2!=0)

  }

4.2 map

/**
   * map:(p:A => B)
   * 将集合中的所有元素A都作用在该匿名函数p上，每一个元素都调用一次，元素A转化为B
   * A和B的数据类型可以不一致
   * map的操作就是一个one-2-one的映射操作
   */
 def mapOps(): Unit ={
   //将集合中的元素扩大1.5倍
   val array = 1 to 5
   var newArr = array.map((nem:Int)=>num*1.5)
   //化简
   var newArr1 = array.map(_ * 1.5)
 }

4.3 flatMap

/**
   * flatMap:(f:A=>Traversable[B])
   * 和map不同之处在于作用于匿名函数的返回值类型不同
   * map：one-2-one
   * flatMap:one-2-many,类似于sql中列转行的操作
   *
   * foreach
   */
 def flatmapOps: Unit ={
   val array = Array("a dog","a monkey","a cat")
   //提取集合中的每一个单词
   val words = array.flatMap((line:String)=>{
     line.split("\\s+")
   })
   //简化
   val words2 = array.flatMap(_.split("\\s+"))

   words2.foreach(println)
 }

4.4 reduce

  /**
   * reduce:(p:(A,A)+>A)
   * reduce是一个聚合函数，将两个A转化为一个A，集合中的元素进行聚合操作，得到新的值
   * 例如：求和操作
   *      var sum =0
   *      for(i<- 1 to 5){
   *        sum = sum +i
   *      }
   * 第一个A：sum
   * 第二个A：i
   * 第三个A：聚合结束后的结果
   */
 def reduceOps: Unit ={
   val array = 1 to 6
   var sum = 0

   sum = array.reduce(_ + _)
   println(sum)
 }

4.5 dropWhile

  /**
   * dropWhile:(p:A=>Boolean)
   * 该函数和filter一样，作用在集合的每一个元素，返回值为boolean类型
   * dropWhile删除元素，直到不满足条件位置
   */
 def dropWhileOps: Unit ={
   val array = Array(3,-6,7,1,0,9,4,2)
   //循环删除其中的偶数,直到条件不满足
   val arr = array.dropWhile(_%2!=0)
   arr.foreach(println)
 }

4.6 sortwith

  /**
   * sortWith:排序操作
   * ((A,A)=>boolean)，返回值是布尔值
   */
 def sortWithOps: Unit ={
   val array = Array(3,-6,7,1,0,9,4,2)
   val array1 = array.sortWith((v1,v2)=>v1<v2)
   array.foreach(print)
 }

4.7 groupBy

/**
   * groupBy:分组操作
   */
 def groupByOps: Unit ={
   val array = Array(
     "a,b",
     "a,c",
     "d,e",
     "d,f",
     "g,h"
   )
   //分组
   val arr = array.groupBy(line => line.substring(0,line.indexOf(",")))

   //将原来的集合进行分组，每个组内元素有两个
   val arr2 = array.grouped(2)

   for(arr <- arr2){
     println(arr.mkString("[",",","]"))
   }
 }

4.8 partition

  /**
   * partition:按照一定的提交进行分组，最后分为两组
   * (p:A=>boolean):(集合A,集合B)
   * 在每一个元素A上进行作用该匿名函数，满足条件，共同构成返回值集合A，不满足条件的构成集合B
   * 最后完成分区
   */
 def partitionOps: Unit = {
   val array = Array(3,-6,7,1,0,9,4,2)
   //将集合按照4进行分区，小于4一个集合，大于等于4一个集合
   val (left,right) = array.partition(_<4)
   println(left.mkString("[",",","]"))
   println(right.mkString("[",",","]"))
 }