内容如下：
1. 高阶函数的定义；
2. map函数的使用方法；
3. foreach函数的使用方法；
4. filter函数的使用方法；
5. reduce函数;
6.reduceLeft函数;reduceRight函数;
7. fold函数;
8. sorted函数;
9. sortedWith函数;
（一）什么是高阶函数
定义：高阶函数是一种特殊的函数,特殊之处在于:它指使用其他函数作为参数或者返回值。
Scala的常见高阶函数包括Array.map、flatten、flatmap、foreach、reduce、filter和fold等。
（二）map函数
作用：通过对数组的每一个元素应用一个函数来构建一个新数组。
语法： 新数组 = 旧数组.map(旧元素=>新元素)
示例：把数组(-1,2,-3,-4) → (1,2,3,4)
【编码示范】
object base47 {
/**
* map 的练习题
*/
def main(args:Array[String]):Unit={
val arr1 = Array(1,2,3,4,5,6)
val arr2 = arr1.map(x => x * x)
for (i <- arr2){
print(s"${i}")
}
val arr3 = Array(-1,2,-3,-4)
// 绝对值
val arr4 = arr3.map(x => if(x>0) x else -x)
println()
for (i <- arr4){
println(s"${i}")
}
}
}
运行结果：
object base46 {
/**
*
* 高阶函数: 一种特殊的函数，它的参数或者返回值是函数类型。
* 1. map函数
*/
def main(args:Array[String]):Unit={
val arr1 = Array(1,2,3,4,5,6)
// Array 是一个构造器，用来定义一个数组。
// arr1 就是一个数组对象，它有很多的方法，其中就有map。
// for 循环来输出数组中每个元素
val fn = (x:Int) => x * 2
// fn是一个函数，它被传给了map。map是一个高阶函数
val arr2 = arr1.map(fn)
// for 循环来输出数组中每个元素
for (i <- arr2){
println(i)
}
}
}
运行结果：
（三）foreach函数
作用：对数组的每一个元素应用函数。
语法：数组.foreach(元素=>{})
【编码示范】
object base48 {
/**
* 2.foreach函数
* 是数组的每一个元素都执行一次 函数
*/
def main(args:Array[String]):Unit={
val arr1 = Array(1,2,3,4,5,6)
// arr1.foreach(x => print(x))
arr1.foreach(print)
arr1.foreach(println)
// for (i <- arr1) {
// println(s"${i}")
//}
}
}
// 运行结果：1234561
// 2
// 3
// 4
// 5
// 6
（四）filter函数
作用：对数组元素使用函数进行过滤。
语法：新数组= 旧数组.filter(元素=>bool) 它的参数是一个函数，这函数的返回值是布尔值。如果返回为true就保留。
示例:在数组中找出元素是偶数的，并组成新数组。(1,2,3,4,5) → (2,4) ; 去掉不及格的分数：(60,59,80,70) → (60,80,70)
【编码示范】
object base49 {
/**
* 3.filter函数
* 过滤器。
* filter(函数)
* 如果函数的返回值为true，则元素就保留下来
*/
def main(args:Array[String]):Unit= {
// 把数值为偶数的留下来
val arr1 = Array(1, 2, 3, 4, 5)
// val arr2 = arr1.filter(x => {
// println(x)
// x%2 == 0
// })
val arr2 = arr1.filter(x => x%2==0)
arr2.foreach(println)
var score = Array(90,98,60,49,100)
// 把小于80分的去掉，只保留大于80分的分数
score.filter(x => x>80).foreach(println)
}
}
（五）reduce函数
作用：reduce 是一种集合操作，用于对集合中的元素进行聚合操作，返回一个单一的结果。它通过指定的二元操作（即取两个元素进行操作）对集合中的所有元素进行递归处理，并最终将其合并为一个值。
语法:reduce 函数需要一个函数作为参数，这个函数接受两个相同类型的参数，并返回一个值。
【编码示范】
object base50 {
/**
*
*/
def main(args:Array[String]):Unit= {
val arr = Array(1,2,3,4,5)
// 求数组元素的累加
val rst = arr.reduce( (x,y)=> x + y)
//val rst = arr.sum
println(s"rst = ${rst}")
val rst1 = arr.reduce( (x,y)=> x - y)
println(s"rst1 = ${rst1}")
}
}
//运行结果：rst = 15
// rst1 = -13
（六）reduceLeft函数;reduceRight函数
定义：reduceLeft是从集合的左侧开始聚合，与reduce等价； reduceRight是从集合的右边开始。
【编码示范】
object base51 {
//reduce ==== reduceLeft 从左向右计算
// reduceRight 从右向左计算
def main(args:Array[String]):Unit= {
val arr = Array(1,2,3)
val rst = arr.reduceLeft( (x,y)=> x - y)
val rst1 = Array(1,2,3,4).reduceRight( (x,y)=> x - y)
println(s"rst = ${rst}")
println(s"rst1 = ${rst1}")
}
}
//运行结果：rst = -4
// rst1 = -2
（七）fold函数
作用：fold 是一种集合操作（与reduce类似），用于对集合中的元素进行聚合操作，返回一个单一的结果，需要提供一个初始的“种子”值。
语法：数组.fold(初值)(函数)
【编码示范】
object base52 {
// fold：带初值的reduce
def main(args:Array[String]):Unit= {
val rst = Array(1,2,3).fold(10)((x,y)=>x+y)
println(s"rst = ${rst}")
}
}
//运行结果：rst = 16
（八）sorted函数
作用:对元素进行排序。它会直接使用元素自身的自然顺序进行排序
语法:新数组 = 原数组.sorted
【编码示范】
object base53 {
// sorted
def main(args:Array[String]):Unit= {
// 对数值元素排序： 从小到大排序
var arr = Array(-1,10,-2,1,2,3).sorted
arr.foreach(println)
// 对字符元素排序，字典顺序
var arr2 = Array("zoom","bus","apple","banana","car").sorted
arr2.foreach(println)
}
}
//运行结果：-2
// -1
// 1
// 2
// 3
// 10
// apple
// banana
// bus
// car
// zoom
（九）sortedWith函数
作用:按自定义规则排序
语法:新数组 = 原数组.sortedWith(排序函数)
排序函数:（元素a,元素b)=>Bool。如果返回 true，则 表示元素a应排在元素b之前。
【编码示范】
object base54 {
// sortWith:自定义排序
// sortWith((x,y) => 布尔值)
//(1) 如果返回值是true,那x就在y的前面
//(2) 如果返回值是false,那x就在y的后面
def main(args:Array[String]):Unit= {
//
var arr = Array(-1,10,-2,1,2,3).sortWith((x,y) => Math.abs(x - 1) < Math.abs(y - 1))
arr.foreach(println)
}
}
// 运行结果：1
// 2
// -1
// 3
// -2
// 10
