有哪些⾼阶函数?

使用其他函数作为参数、或者返回一个函数作为结果的函数。在Scala中函数是“一等公民”，所以允许定义高阶函数。使用函数值作为参数，或者返回值为函数值的“函数”和“方法”，均称之为“高阶函数”。

### 1.高阶函数 map/filter/sorted/sortWith/sortBy/groupBy

```java
def map[B](f: A => B):B //map是映射,只要涉及到数据结构变化的可以用map
```

```java
object ListDemo2 extends App{
//1.对集合中数据进行遍历操作map/filter
val list = List(1,2,3,4,5)
//2.集合中数据都*2
val list_map: List[Int] = list.map(_*2)
//3.将集合中数据进行过滤 奇数
val list_filter: List[Int] = list.filter(_%2==1)
//4.打印集合中数据
list.foreach(println(_))
//5.对集合中的数据进行排序
val sorted_1: List[Int] = list.sorted
//6.对集合中数据进行自定义排序
val sorted_2: List[Int] = list.sortWith(_ > _ ) // 降序
val sorted_3: List[Int] = list.sortWith(_ < _) //升序 //对集合中所有数据求和 val sum: Int = list.sum //groupBy()根据什么分组 list.groupBy(x=>{x}) //根据集合中元素分组
再比如：
val list2 = List("11","12","21","22")
list2.groupBy(x=>{x.substring(0,1)})//根据字符串第一个字符来分组

//sortBy根据规则排序
val list3 = List(1,2,4,3)
list3.sortBy(x=>x)
```

### 2.高阶函数 flatmap

效果就是将集合中的==每个元素的子元素==映射到某个函数并返回新的集合

```java
val list1 :List[List[Int]]= List(List(1,2,3),List(4,5,6),List(7,8),List(9))
//需求将当前list1中集合数据变成 List(1,2,3,4,5,6,7,8,9)
//此时scala中提供了一种可以对集合中存储着复杂数据类型的数据进行扁平化处理(将数据拆开)
val list2: List[Int] = list1.flatMap(_.toList)
print(list2)

flatten + map 等同于flatmap
val list:List[String] = List("ni hao","wo hao")
val maped : List[String] = list.map(_.split(" ")) //List(List(ni,hao),List(wo,hao))
val flatten: List[String] = maped.flatten // List(ni,hao,wo,hao)
```

### 3.patition/find/takeWhile

```scala
//partition --> 将不同数据处理过后的结果写入到不同文件中(多文件输出)
//list2.partition("分区规则")
val tuple: (List[Int], List[Int]) = list2.partition(_ %2 ==0)
//find 查找 --> 完全类似于 filter
//若找到了满足条件的值,值不会直接返回而是返回一个Option的子类即Some,没有找到返回None
val maybeInt: Option[Int] = list2.find(_%2==0)

//takeWhile 查找 --> 匹配每一个元素,直到不能匹配为止
val list6: List[Int] = List(1,2,3,-4,5).takeWhile(_ > 0)
```

### **4.高阶函数 reduceLeft和reduceRight**

```scala
//reduce求和 有主类 reduceLeft 和 reduceright
//本质上和sum是一样的 它需要两个参数
//第一个参数有两个作用
/**
* 第一次:第一个参数获取的是集合中第一个元素的值
* 以后每一次计算: 上一次计算的结果值 即 x+y所产生的结果 相当于 x = x+y
*/
//第二个参数
/**
* 第一次: 获取的是集合中第二个元素的值
* 以后每一次计算: 集合中从第二个元素开始逐渐向后获取每一个元素的值
*/
//当前集合中元素都计算完成的时候,集合停止
val list2 = List(1,2,3,4,5)
val sum = list2.reduce((x:Int,y:Int)=>{
println("--->"+x)
println("--->"+y)
x+y
})
println("求和"+ sum)
```

### 5.高阶函数 fold

```scala
//fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的所有元素被遍历

//fold 求和 有两个主要使用的类 foldLeft 和 foldright
// fold是有两个参数 第一个参数是默认值(在计算的时候进行添加) 第二参数是计算方式
// fold是存在默认值的 ,这个默认值会在计算的时候参与整个计算流程
// 第二个小括号中 第一个参数第一次获取的是默认值 第二参数获取的是集合中值
// 以后每次运算第一参数获取的上一次计算的值,第二参数获取的是集合中值
// fold默认值为0的前提下,和reduce的计算效果完全相同,如果提供非0默认值,结果将完全不同

val list2_1 = List(1,2,3,4,5)
val sum1 = list2_1.fold(2)((res:Int,n:Int)=>{
println("--> "+res)
println("--> "+n)
res+n
})
结果；
--> 2
--> 1
--> 3
--> 2
--> 5
--> 3
--> 8
--> 4
--> 12
--> 5

 foldLeft和foldRight 缩写方法分别是：/:和:\

  val b: Int = list.foldRight(1)(_-_)   就等同于    val b: Int = (list:\1)(_-_)

  val c: Int = list.foldLeft(1)(_-_)     就等同于    val c: Int = (1/:list)(_-_)

```

### 6.高阶函数 zip 扩展-拉链(合并)

#### zip / zipAll / zipwithIndex / unzip

```scala
package Tuple_

import java.io

object ZipDemo {
def main(args: Array[String]): Unit = {
//zip将两个集合中元素拼接成kv形式对偶元组形式
//ps:在Spark中说kv 第一反应元组 然后在是Map
val name = Array("tom","jerry","kitty")
val scores = Array(2,3,4)
//此时需要将两个集合中的元素生成对偶元组,在没有zip之前
//先创建一个元组 然后遍历两个集合分别取出里面值(下标),然后在将值存储到元组中

//谁在前调用方法谁就是key后面传入的传入的参数就是value
val tuples: Array[(String, Int)] = name.zip(scores)
//Array[(String, Int)] --> Array是关键字主要是告诉操作者 存储的方式是什么[List|Set|Map]
//[] --> scala中表示泛型的方式 ,说明集合集合中存储元素的数据类型
// () --> 代表的是元组 ,()内部中数据类型String,Int代表的是元组中元素的数据类型
//Array数组中存储着对偶元组,元组中的数据类型是String 和Int
println(tuples.toBuffer)

//如果数组中的元素长度不一致
//拉链操作后生成新的元组长度是以 短的集合的长度为依据 多余的部分会被舍弃调
val name1 = Array("tom","jerry","kitty")
val scores2 = Array(2,3)
val tupless: Array[(String, Int)] = name1.zip(scores2)
println(tupless.toBuffer)

// zipAll

//zipAll 方法和zip类似, 若其中某一个集合中元素较少,会使用默认值填充
//三个参数:
//1.是要进行拉链操作的集合
//2.是执行拉链操作是集合中获取的值即第一个参数中元素的值
//3.若集合中值不够,此时最后当前参数作为默认值填充
val tuplesss: Array[(io.Serializable, Int)] = name1.zipAll(scores2,scores2,0)
println(tuplesss.toBuffer)

//zipwithIndex

//zipwithIndex 将集合中元素和索引值进行组合(对偶元组)
val arr = Array(1,2,3,4,5)
val tuplessss: Array[(Int, Int)] = arr.zipWithIndex //获取的是下标
println(tuplessss.toBuffer)//ArrayBuffer((1,0), (2,1), (3,2), (4,3), (5,4))

//扩展:可以使用zip完成相同事情arr.zip(Stream from 1)
//ps: 拉链操作同样适用于 List集合

//解拉链 unzip
//相当于将key归类到一个集合中 value归类到一个集合中
val unzip: (Array[io.Serializable], Array[Int]) = tuplesss.unzip

}

}
```

### 7.高阶函数 扩展-迭代器 iterator

通过iterator方法从集合获得一个迭代器，通过while循环和for表达式对集合进行遍历。iterator 的构建实际是 **AbstractIterator** **的一个匿名子类**，该AbstractIterator子类提供了 **hasNext next** 等方法

```scala
val iterator = List(1,2,3,4,5).iterator
while (iterator.hasNext)
println(iterator.next() + " ")
}
```