Scala的高阶函数（2）

1.collect:通过执行一个并行计算（偏函数），得到一个新的数组对象

val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   println("newchars:"+newchars.mkString(","))
  //我们通过下面的偏函数，把chars数组的小写a转换为大写的A
  val fun:PartialFunction[Char,Char] = {
    case 'a' => 'A'
    case x => x
  }
  /**输出结果是 newchars:A,b,c */

2.collectFirst:在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
3.combinations(n: Int):排列组合，这个排列组合会选出所有包含字符不一样的组合，对于 “abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组

val a=Array("a","b","c")
a.combinations(2)
res1.foreach(x=>println(x.mkString(",")))
//结果为： 
a,b 
b,c
a,c

4.contains(n)->返回boolean值 :判断集合是否包含某一个指定对象

val a=Array("a","b","c")
a.contains("a")  //返回结果为true

5.containsSlice:判断当前序列中是否包含另一个序列，注意：序列需要连续相连才可以，否则都为false

val a=Array("a","b","c")
val b=Array("b","c")
a.containsSlice(b) //true
val c= Array("a","c")
a.containsSlice(c) //false

6.copyToBuffer:将数组中的内容拷贝到Buffer中

    val a=Array(a,b,c)
    val b:ArrayBuffer[String]  = ArrayBuffer()
    a.copyToBuffer(b)
    println(b.mkString(","))
    //输出 a,b,c

7.corresponds:判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true
注意：如果两个集合数组长度不等，返回为错误，必须同等长度

val a=Array(1,2,3)
val b=Array(3,4,5)
a.corresponds(b)(_<_)  //true

8 . count：统计个数，一般要跟条件过滤

val a=Array(1,2,3)
a.count(x=>x>1) //count=2

9.diff:计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

val a=Array(1,2,3)
val b=Array(3,4,5)
a.diff(b) //    (1,2)

10.distinct:对序列去重
11.drop(n: Int)将当前序列中前 n 个元素去除后，作为一个新序列返回

val a=Array(1,2,3)
a.drop(2) // 返回结果为3

12.dropRight(n: Int)，去掉尾部N个元素，同drop方法相反，操作相同
13.dropWhile:去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

//下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val c = a.dropWhile( {x:Int => x > 2} )
println(c.mkString(","))
 
//如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
val a = Array(1, 2, 3,4)

14.endsWith:Boolean:判断是否以某个序列结尾

val a = Array(3, 2, 3,4)
val b=Array(3,4)
a.endsWith(b) //true

15.exists：判断当前数组是否包含符合条件的元素

val a=Array(3, 2, 3,4)
a.exists(x=>x==2)  //true
a.exists(x=>x==5)  //false

16.filter:取得当前数组中符合条件的元素，组成新的数组返回

val a = Array(1, 2, 3,4)
a.filter(x=>x>1)  //返回新数组为（2，3，4）

17.filterNot
与上面的 filter 作用相反
18.find:查找第一个符合条件的元素

val a = Array(1, 2, 3,4)
a.find(x=>x>2)  //返回为some（3）

18.flatMap:对数组的每一个元素进行操作，结果放入新序列返回

val a = Array(1, 2, 3,4)
val b = a.flatMap(x=>1 to x)
println(b.mkString(","))
/**
1,1,2,1,2,3,1,2,3,4
从1开始，分别于集合a的每个元素生成一个递增序列，过程如下
1
1,2
1,2,3
1,2,3,4
*/

19.flatten：将二维数组的所有元素联合在一起，形成一个一维数组返回

val darr=Array(Array(1,2,3),Array(4,5,6))
darr.flatten
//返回（1，2，3，4，5，6）

20.fold 同之前的 :\ 和 /: 的操作方法

val a = Array(1, 2, 3,4)
a.fold(5)(_+_）
//返回结果为1+2+3+4+5=15

21.forall:Boolean检测序列中的元素是否都满足条件 p，如果序列为空，返回true

val a = Array(1, 2, 3,4)
a.forall(x=>x>0) //true
a.forall(x=>x>2)  //false

21.foreach:遍历序列中的元素，进行 f 操作
21.groupBy:按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列

val a = Array(100, 200, 320,4)
val b=a.groupBy(x=>x match{
     | case x if (x<150)=>"small"
     | case x if (x ==200)=>"ok"
     | case x=>"big"
     | })
     //small,ok,big,small

22.grouped(size: Int):按指定数量分组，每组有 size 数量个元素，返回一个集合

val a = Array(100, 200, 320,4)
a.grouped(2)
//第一组为（100，200），第二组为（320，4）

23.hasDefiniteSize: Boolean
检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
24.head:返回序列的第一个元素，如果序列为空，将引发错误,tail是返回除了第一个元素之外的其他元素
25.headOption：返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None

val a = Array(1, 2, 3,4,5)
println(a.headOption)   //Some(1)

26.indexOf(elem: T): Int 返回elem在序列中的索引，找到第一个就返回

val a = Array(1, 2, 3,4,5)
a.indexOf(3)  // 返回为2，就是元素所在的位置下标