Scala的高阶函数

一 Scala高阶函数概
Scala的高阶函数指使用其他函数作为参数或者返回一个函数作为结果的函数。在Scala 中，函数是“一等公民”，所以允许定义高阶函数。这里的术语可能有点让人困惑，一般约定，使用函数值作为参数，或者返回值为函数值的“函数”和“方法”。

  Scala的常见高阶函数包括map、flatten、flatmap、foreach、reduce、filter和fold等。这里只是列举了一些常见的高阶函数，还有一些其他重要的高阶函数，在需要时可以通过查阅相关文档使用即可。 

object Test1 {
  def main(args: Array[String]): Unit = {
    //  定义数组：Array(1,2,3,4)
    var arr = Array(10,22,13,54)//定义一个数组有4个元素
    println( arr(0) )//获取元素 获取第一个元素
    println( arr(2) )//获取第三个元素
    //遍历数组
    for(i <- arr){
      println(i)
    }
  }
}

二 map和foreach函数的应用

  下面介绍两种Scala的常见高阶函数，分别为map和foreach。这两个函数都可以遍历集合对象， 差别之处在于foreach无返回值，map返回集合对象。下面将进一步说明这两种函数的联系和区别。 

1. Scala的map 

  Scala的map解释为:Apply Builds a new array by applying a function to all elements of this array。 返回值构建了一个新的数组通过应用函数遍历数组中的每一个元素。

  语法：

def map[B](f:(T)=>B)(implicit ct:ClassTag[B]):Array[B]

   假设定义一个数组Arr(1,2,3),通过数组调用map,即Arr(1,2,3).map(x=>x+1)，返回值会形成一个新的数组Array(2,3,4)。

相关代码如下：

object Test2 {
  def main(args: Array[String]): Unit = {
    //1.高阶函数-map:映射 y=x+1
    //x:1 y:2
    //x:10 y:11

    //作用：通过对数组的每一个元素应用一个函数构建一个新数组
    var arr2 = Array(1,2,3,4,5).map( x => 2*x )
    for (i <- arr2 ){
      println(i)
    }

    var arr3 = Array(1, 2, 3, 4, 5).map(x => x * x)
    for (i <- arr3) {
      println(i)
    }
  }
}

2.Scala的foreach

  foreach的语法定义与map相似。Scala的foreach解释为:Apply f to each element for its side effcts,。在每个元素上执行指定的程序。

  语法：

def foreach[U](f:(T)=>U):Unit

  两者的差别之处在于foreach没有返回值而map有返回值。常用于打印一些结果，例如通过(1,2,3) 数组调用foreach打印结果，(1,2,3).foreach(x=>printli(x+1)),打印结果为2，3,4。

相关代码如下：

object Test3 {
  def main(args: Array[String]): Unit = {
    var rs = Array(1,2,3,4,5).foreach(x => {
      println(x + 2)
    })
    println(rs)
    Array(1,2,3,4,5).foreach(println)
  }
}

三 filter函数的应用

  Scala的filter函数也是一个应用非常广泛的函数，filter函数的解释为:Selects all elements of this array which satisfy a predicate. 

  语法:

def filter(p:(T)=>Boolean):Array[T]

  根据函数返回值来确定过滤数组中的元素，最终的返回值也是一个数组。如果传递的函数的返回值为真，将保留元素中的值，如果为假则过滤元素。在实际应中可以使用filter过滤一些以字母开头的名称、某些IP等方面。

相关代码如下：

object Test4 {
  def main(args: Array[String]): Unit = {
    var rs = Array(1,2,3,4,5).filter(x => {
      if (x % 2 == 0)
        true
      else
        false
    })
    rs.foreach(println)
  }
}

四 flatten和flatmap函数的应用
  下面介绍Scala的高阶函数中的另外两个函数，分别为flatten和flatmap。在实际应用中flatmap 比 flatten应用更广泛，下面将进一步说明这两种函数的联系和区别。

1. Scala 的 flatten

  Scala的flatten的解释为:Flattens a two-dimensional array by concatenating all its rows into a single array。将二维数组中的元素展平至单数组中。

  语法：

def flatten[B](implicit asIterable: (T) => collection.IterableOnce[B], m:ClassTag[B]); Array[B]

相关代码如下：

object Test5 {
  def main(args: Array[String]): Unit = {    
    //flatten:作用把二维数组展开成一维数组
    //定义一维数组：Array(1,2,3,4)
    //二维数组：数组的元素还是一个数组
    var arr = Array(
      Array(30,40,50),
      Array(70,80,90),
      Array(31,42,51)
    )
    //如何输出30？
//    println(arr(0)(0))
    //arr.foreach(println)

//    arr2.foreach(println)
    //求二维数组中最大元素
    //1.先转成一维数组
    var arr2 = arr.flatten
    //2.再求最大值
    println(arr2.max)
  }
}

五 reduce、reduceleft和fold函数的应用

  下面介绍Scala的高阶函数中的三种常用函数，分别为reduce、 reduceleft和fold。在实际应用中flatmap 比flatten 应用更广泛，下面具体说明这三种函数的相关知识。

1.Scala的reduce

  Scala的reduce 的解释为:Reduces the elements of this immutable sequence using the specified associative binary operator。对不变序列的每个元素执行指定的二元规约操作。

  语法：

def reduce[B >: A](op: (B,B) => B): B

  reduce接受两个参数返回一个参数，例如对数组中的所有元素求和，通过调用reduce来实现(1,2,4,3).reduce((x,y)=>(x+y)通过把集合中的第一个元素赋值给x，第二个元素赋值给y，即x=1, y=2,并对这两个值求和。然后把和赋值给x，第三个元素赋值给y，即x=3,y=4,再次求和。通过将每一次表达式的结果赋值给x，将下一个元素的值作为y的值，依此类推，最终结果为10。 

相关代码如下：

object Test6 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    Array(1,2,3,4,5)
    //求和 (1,2,3,4,5) ===> 一个值
    val res = Array(1,2,3,4,5).reduce((x,y)=>x + y)
    println(res)
  }
}

2. Scala 的 reduceleft 

  Scala的reduceleft的解释为:Applies a binary operator to all elements of this immutable sequence. going left to right。 reduceleft是按照从左至右的取值顺序进行运算，reduceleft 还有一个相似的函数reduceRight是按照从右至左的顺序取值运算。

  语法：

def reduceLeft[B >: A](op: (B,T) => B): B

相关代码如下：

object Test7 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    Array(1,2,3,4,5)
//    val res1 = Array(1,2,3,4,5).reduceLeft((x,y)=>x + y)
//    val res2 = Array(1,2,3,4,5).reduceRight((x,y)=>x + y)
//    println(res,res2,res3)//1+2+3 = 3+2+1
    val res1 = Array(1, 2, 3, 4).reduceLeft((x, y) => x - y)//-8
    val res2 = Array(1, 2, 3, 4).reduceRight((x, y) => x - y)//-2
    println(res2,res3)//(-8,-2)
  }
}

3. Scala 的 fold

  Scala的fold的解释为:Folds the elements of this array using the specificd associative binary operator, 对数组的每个元素执行指定的二元折叠操作。

  语法：

def fold[A1 >: A](z: A1)(op: (A1,A1) => A1): A1

  fold与前两者的不同之处在于fold有一个初始值，在取值运算的过程中第一个元素需要先与初始值进行运算，再依次进行下一步的运算。

相关代码如下：

object Test8 {
  def main(args: Array[String]): Unit = {
    //定义一个数组
    Array(1,2,3,4,5)
    //fold作用：带初始值是reduce
//          格式：fold(初始值)(二元函数 => 返回值)
//    val res1 = Array(1000,1500,1200,1800,2000).fold(100000)((x,y)=>x +y)
    val res1 = Array(1000,1500,1200,1800,2000).fold(100000)((x,y)=>if(x>y) y else x)
    println(res1)
  }
}