大数据基础之Scala——Scala数组方法，史上最全，只要你能全部背上即可成为万人敬仰的大佬，任何Scala随便戳戳！！！

Scala数组

数组是一种可变的、可索引的数据集合。在Scala中用Array[T]的形式来表示java中的数组形式T[ ]。

//声明一个数组对象
方法一：var numbers:[String]=new Array[String](3) 
方法二：val numbers = Array(1, 2, 3, 4)
           
val first = numbers(0)                          // 读取第一个元素
numbers(3) = 100                                // 替换第四个元素为100
val biggerNumbers = numbers.map(_ * 2)          // 所有元素乘2

数组方法：

大概120多个，如果能全部背上，即可化身为令人膜拜敬仰的大佬，秒杀一切！

scala> var arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> arr.
++              filterNot            maxBy               span
++:             find                 min                 splitAt
+:              flatMap              minBy               startsWith
/:              flatten              mkString            stringPrefix
:+              fold                 nonEmpty            sum
:\              foldLeft             orElse              tail
addString       foldRight            padTo               tails
aggregate       forall               par                 take
andThen         foreach              partition           takeRight
apply           genericBuilder       patch               takeWhile
applyOrElse     groupBy              permutations        to
array           grouped              prefixLength        toArray
canEqual        hasDefiniteSize      product             toBuffer
clone           head                 reduce              toIndexedSeq
collect         headOption           reduceLeft          toIterable
collectFirst    indexOf              reduceLeftOption    toIterator
combinations    indexOfSlice         reduceOption        toList
companion       indexWhere           reduceRight         toMap
compose         indices              reduceRightOption   toSeq
contains        init                 repr                toSet
containsSlice   inits                reverse             toStream
copyToArray     intersect            reverseIterator     toTraversable
copyToBuffer    isDefinedAt          reverseMap          toVector
corresponds     isEmpty              runWith             transform
count           isTraversableAgain   sameElements        transpose
deep            iterator             scan                union
diff            last                 scanLeft            unzip
distinct        lastIndexOf          scanRight           unzip3
drop            lastIndexOfSlice     segmentLength       update
dropRight       lastIndexWhere       seq                 updated
dropWhile       lastOption           size                view
elemManifest    length               slice               withFilter
elemTag         lengthCompare        sliding             zip
endsWith        lift                 sortBy              zipAll
exists          map                  sortWith            zipWithIndex
filter          max                  sorted

我祝各位来观赏的大佬心情愉快！哈哈哈

详细讲解：

​ 1.++
​ def ++[B] (that:Gen TraversableOnce[B]):Array[B]
​ 合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。

var c = Array(2,3,4,67,88)
var a = Array(56,3,32,54)
c++a
res:Array[Int] = Array(2,3,4,67,88,56,3,32,54)

​ 2.++:
​ def ++:[B >: A, That] (that: collection.Traversable[B])(implicit bf:CanBuildFrom[Array[T], B, That]): That
​ 这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型。下面代码中Array和LinkedList结合，返回结果的类型是LinkedList。

var arr = Array(1,2,3,4,5,6)
var lst = LinkedList(45,34,33,22)
arr.++:lst
res:LinkedList[Int] = LinkedList(1,2,3,4,5,6,45,34,33,22)

​ 3.+: 以及 :+
​ def +:(elem:A):Array[A]
​ def :+(elem:A):Array[A]
​ +: 是在数组前面添加一个元素，并返回新的对象，下面添加一个元素20。
​ :+ 同上面的方法相似，但是是在数组末尾添加一个元素，并返回新的对象

var k=20
var arr = Array(2,3,4,5)
k+:arr
res:Array[Int] = Array(20,2,3,4,5)
arr:+k
res:Array[Int] = Array(2,3,4,5,20)

4. /: 和 :\
   ​ def /:[B] (z:B)(op:(B,T)=>B):B
   ​ def :\ [B] (z:B)(op:(T,B)=>B):B
   ​ /: 对数组中所有的元素进行相同的操作，foldLeft的简写
   ​ :\ foldRight的简写

val a = List(1,2,3,4)
(100 /: a)(_+_)
res:110
//左右的数值类型要对应，冒号在哪边，集合就在哪边

​ 5.addString
​ (1)def addString(b:StringBuilder):StringBuilder
​ 将数组中的元素逐个添加到StringBuilder中
​ (2)def addString(b:StringBuilder,sep:String):StringBuilder
​ 同上，每个元素以sep分隔符分开
​ (3)def addString(b:StringBuilder,start:String,sep:String,end:String)
​ :StringBuilder
​ 同上，在首尾各加一个字符串，并指定sep分隔符

val a = List(1,2,3,4)
var str = new StringBuilder()
a.addString(str)
res:StringBuilder = 1234

a.addString(str,"#")
res:StringBuilder = 12341#2#3#4

a.addString(Str,"[",",","]")
res:StringBuilder = [1,2,3,4]

6.aggregate
def aggregate[B] (z:=>B)(seqop:(B,T)=>B,combop:(B,B)=>B):B
聚合计算，aggregate是柯里化方法，参数是两个方法，为了方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。
在这之前首先解释一下par（分区的概念）：
Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算。
主要用到的算法有：
Divide and conquer : 分治算法，Scala通过splitters，combiners等抽象层来实现，主要原理是将计算工作分解很多任务，分发给一些处理器去完成，并将它们处理结果合并返回
Work stealin：算法，主要用于任务调度负载均衡（load-balancing），通俗点完成自己的所有任务之后，发现其他人还有活没干完，主动（或被安排）帮他人一起干，这样达到尽早干完的目的。

(1 to 5).foreach(println(_))
res:
1
2
3
4
5

(1 to 5).par.foreach(println(_))
3
1
4
2
5

​ aggregate案例

  def main(args: Array[String]) {
    val a = List(1,2,3,4)
    val c = a.par.aggregate(5)(seqno,combine)
    println("c:"+c)
  }
  def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
  def combine(m:Int,n:Int): Int ={
    val s = "com_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
res:
    seq_exp=5+3
    seq_exp=5+2
    seq_exp=5+4
    seq_exp=5+1
    com_exp=6+7
    com_exp=8+9
    com_exp=13+17
    c:30

​ 上面的过程可以简写为

val c = a.par.aggregate(5)(_+_,_+_)

7.apply
def apply(i:Int):T
取出指定索引处的元素

var a = Array(23,65,786,54)
c.apply(2)
res:Int=786

8.canEqual
def canEqual(that:Any):Boolean
判断两个对象是否可以进行比较

var c = Array(23,54,675,867)
var d = Array(2,3,45,5)
c.canEqual(d)
res:Boolean = true

c.canEqual('z')
res:Boolean = true

object myObj{}
c.canEqual(myObj)
res:Boolean = true     //对象也可以比较

//理论上讲数组可以和大部分都可以比较

9.charAt
def charAt(index:Int):Char
获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转化为ArrayCharSequence,只有当T为Char类型时，这个转换才会发生。

var a = Array('a','b','c')
a.char(1)
res:char = b

10.clone
def clone():Array[ ]
创建一个副本

var c = Array(23,65,76,54,43)
var e = c
e:Array[Int] = Array(23,65,76,54,43)
c(2) = 44
c:Array[Int] = Array(23,65,44,54,43)
e:Array[Int] = Array(23,65,44,54,43)
直接赋值的本体变了，副本也会变

var k = c.clone
c(2) = 100
c:Array[Int] = Array(23,65,100,54,43)
k:Array[Int] = Array(23,65,76,54,43)
拷贝副本，本值改了，克隆的值不会改变

11.collect 重点！！！
def collect[B] (pf:PartialFunction[A,B]):Array[B]
通过执行一个并行计算(偏函数),得到一个新的数组对象
偏函数概念：
在Scala中，偏函数是具有类型PartialFunction[-T,+V]的一种函数，T是其接受的函数类型，V是其返回的结果类型。偏函数最大的特点就是它只接受和处理其参数定义域的一个子集，而对于这个子集之外的参数则抛出运行时异常。这与Case语句的特性非常契合，因为我们在使用case语句是，常常是匹配一组具体的模式，最后用“_”来代表剩余的模式。如果一一组case语句没有涵盖所有的情况，那么这组case语句就可以被看做是一个偏函数。

var c = Array(23,34,100,76,88,881)
val fun:PartialFunction[Int,Int] = {
	case x=>x+1     //所有值+1
}
c.collect(fun)
res:Array[Int] = Array(24,35,101,77,89,882)

val fun:PartialFunction[Int,Int] = {
	case 23 => 123
}
//不写case x=>x的话，其他进不去，所以偏函数将其他值去掉了
c.collect(fun)
res:Array[Int] = Array(123)

val fun:PartialFunction[Int,Int] = {
	case 23 =>123                //遇到23 换成123
	case y if y%2==0 => y+1000   //偶数+1000
	case x => x
}
c.collect(fun)
res:Array[Int] = Array(123,1034,1100,1076,1088,881)

val fun:PartialFunction[Int,String] = {
	case 23 => "xixi"
	case y if y%2==0 =>"gg"
	case x =>x+"ff"
}
c.collect(fun)
res:Array[String] = Array(xixi,gg,gg,gg,gg,881ff)

12.collectFirst
def collectFirst[B] (pf: PartialFunction[T, B]):Option[B]
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

var arr = Array(1,'a','b')
//定义一个偏函数，要求当被执行对象为Int类型时，进行乘100的操作，对于上面定义的数组arr来说，只有第一个元素符合要求
var fun:PartialFunction[Any,Int] = {
	case x:Int=>x*100
}
val value = arr.collect(fun)
println("value"+value)
//另一种写法
val value = arr.collectFirst({case x:Int=>x*100})

13.combinations
def combinations(n: Int): collection.Iterator[Array[T]]
排列组合，这个排列组合会选出所有包含字符不一样的组合，对于“abc”、“cba”，只选择一个，参数n表示序列长度，就是几个字符为一组。

var c = Array(23,34,100,76,88,881)
var ee = c.combinations(3)
res:Iterator[Array[Int]] = non-empty iterator
//迭代器只能操作一遍  但是数组可以执行多次
ee.foreach(x=>println(x.mkString(",")))    //把数组中字符以","连接在一起
res:23,34,100
23,34,76
23,34,88
23,34,881
23,100,76
23,100,88
23,100,881
23,76,88
23,76,881
23,88,881
34,100,76
34,100,88
34,100,881
34,76,88
34,76,881
34,88,881
100,76,88
100,76,881
100,88,881
76,88,881

14.contains
def contains[A1 >: A] (elem: A1): Boolean
序列中是否包含指定对象

var c = Array(23,34,100,76,88,881)
c.contains(50)
res:Boolean = false

c.contains(881)
res:Boolean = true

15.containsSlice
def containsSlice[B] (that: GenSeq[B]): Boolean
判断当前序列是否包含另一个序列

var c = Array(23,34,100,76,88,881)
var d = Array(23,34,50)
c.containsSlice(d)
res:Boolean = true

//删除d中的50
k = d.dropRight(1)
res:Array[Int] = Array(23, 34)

scala> c.containsSlice(k)
res32: Boolean = true

16.copyToArray
def copyToArray(xs: Array[A]): Unit
def copyToArray(xs: Array[A], start: Int): Unit
def copyToArray(xs: Array[A], start: Int, len: Int): Unit

val a = Array(0,0,0,0,0,0,0)
var c = Array(23,34,100,76,88,881)
c.copyToArray(a,2)
res:Array[Int] = Array(0,0,23,34,100,76,88)
//拷贝c的内容到a中，从a的第二个位置开始拷贝

17.copyToBuffer
def copyToBuffer[B >: A] (dest: Buffer[B]): Unit
将数组中的内容拷贝到Buffer中 数组变集合

import scala.collection.mutable.ArrayBuffer
var c = Array(23,34,100,76,88,881)
var a :ArrayBuffer[Int] = ArrayBuffer()
c.copyToBuffer(a)
res: Array[Int] = Array(23, 34, 100, 76, 88, 881)
//和前一个差不多 但是只能全量拷贝

18.corresponds
def corresponds[B] (that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

var c = Array(23,34,100,76,88,881)
var a = Array(23,34,100,76,88,881)
c.corresponds(a)(_==_)
res:Boolean = true

var b = Array(23,34,100,88,881)
c.corresponds(a)(_==_)
res:Boolean = false

19.count 重点！！！
def count(p: (T) ⇒ Boolean): Int
统计符合条件的元素个数，下面统计大于 2 的元素个数

var c = Array(23,34,100,76,88,881)
c.count(p=>p%2==0)
res:Int = 4
//count后面带条件 统计符合条件的个数

20.diff
def diff(that: collection.Seq[T]): Array[T]
计算当前数组与另一个数组的不同。将当前数组中没有在另一个数组中出现的元素返回

var c = Array(23,34,100,76,88,881)
var a = Array(23,34,100,88,881)
c.diff(a)
res:Array[Int] = Array(76)

21.distinct
def distinct: Array[T]
去除当前集合中重复的元素，只保留一个！！！

var c = Array(23,34,100,76,88,881)
c=c:+23
res:Array[Int] = Array(23, 34, 100, 76, 88, 881,23)
c.distinct
res:Array[Int] = Array(23, 34, 100, 76, 88, 881)

22.drop 重点！！！
def drop(n: Int): Array[T]
将当前序列中前 n 个元素去除后，作为一个新序列返回

val a = Array(1,2,3,4)
val c =a.drop(2)
println(c.mkString(","))      //3,4

23.dropRight
def dropRight(n: Int): Array[T]
功能同drop，去掉尾部的n个元素

val d = Array(23,34,50)
d.dropRight(1)
res:Array[Int] = Array(23,34)

24.dropWhile
def dropWhile(p: (T) ⇒ Boolean): Array[T]
去除当前数组中符合条件的元素，这需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

var a = ArrayBuffer(23,34,100,88,881)
a.dropWhile(p=>p%2==1)
res:Array[Int] = ArrayBuffer(34,100,88,881)

25.endsWith
def endsWith[B] (that: GenSeq[B]): Boolean
判断是否以某个序列结尾

var a = Array(3,2,3,4)
val c = Array(2,3,4)
a.endsWith(c)
res:Boolean = true

26.exists
def exists(p: (T) ⇒ Boolean): Boolean
判断当前数组是否包含符合条件的元素

var a = Array(3,2,3,4)
a.exists(p=>p>5)
res:Boolean = false
a.exists(p=>p>2)
res:Boolean = true

27.filter 重点！！！！！！！不会基本无缘scala
def filter(p: (T) ⇒ Boolean): Array[T]
取得当前数组中符合条件的元素，组成新的数组返回

var a = Array(3,2,3,4)
a.filter(p=>p%2==0)
res:Array[Int] = Array(2,4)

关于filter的高阶函数写法：

//怎么在filter里面嵌入自己写的函数： 简单演示
def myfun(p:Int):Boolean={
     p%2==0
}
 var a = Array(3,2,3,4)
a.filter(myfun)
res:Array[Int] = Array(2, 4)

28.filterNot
def filterNot(p: (T) ⇒ Boolean): Array[T]
与上面的filter作用相反

var a = Array(3,2,3,4)
a.filterNot(p=>p%2==0)
res:Array[Int] = Array(3,3)

29.find
def find(p: (T) ⇒ Boolean): Option[T]
查找第一个符合条件的元素

var a = Array(3,2,3,4)
a.find(x=>x==2)
res:Option[Int] = Some(2)
//some数组必须用get方法才能读出来
a.find(x=>x==2).get
res:Int = 2

30.flatten 重点！！！
flatMap
def flatMap[B] (f: (A) ⇒ GenTraversableOnce[B]): Array[B]
对当前序列的每个元素进行操作，结果放入到新序列返回，参数要求是GenTraversableOnce及其子类，即先map再进行flat操作：

val c = Array(4,5,6)
//flatmap将map的结果扁平化了 将里面的元素释放出来
c.flatMap(x=>(1 to x))
res:Array[Int] = Array(1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6)

c.map(x=>(1 to x))
res:Array[scala.collection.immutable.Range.Inclusive] = Array(Range(1,2,3,4), Range(1,2,3,4,5), Range(1,2,3,4,5,6))

c.map(x=>(1 to x)).flatten
res: Array[Int] = Array(1,2,3,4,1,2,3,4,5,1,2,3,4,5,6)

有个很重要的概念：
map().flatten = flatMap()

31.flatten
def flatten[U] (implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]):Array[U]
将二维数组的所有元素联合在一起，形成一个一维数组返回

val arr = Array(Array(1,2,3),Array(4,5,6))
val c = arr.flatten
println(c.mkString(","))            //1,2,3,4,5,6

32.fold 重点！！！
def fold[A1 >: A] (z: A1)(op: (A1, A1) ⇒ A1): A1
对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同，我们来对比一下他们的过程。
对于fold我们需要了解一下函数柯里化的概念
在js中我们举个例子：

如最后的console就是函数柯里化的表现
Scala函数柯里化(Currying)：柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

val c = Array(4,5,6)
c.fold(5)(_+_)
res:Int = 20

def myfun(m:Int,n:Int):Int={
  	m+n
}
c.fold(3)(myfun)
res:Int = 20

33.foldLeft
def foldLeft[B] (z: B)(op: (B, T) ⇒ B): B
从左到右计算，简写方式：def /:[B] (z: B)(op: (B, T) ⇒ B): B

def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1,2,3,4)
    val b = a.foldLeft(5)(seqno)
    /** 运算过程
    seq_exp=5+1
    seq_exp=6+2
    seq_exp=8+3
    seq_exp=11+4
    */
    /**
    简写 (5 /: a)(_+_)
    */

34.foldRight
def foldRight[B] (z: B)(op: (B, T) ⇒ B): B
从右到左计算，简写方式：def :[B] (z: B)(op: (T, B) ⇒ B): B

def seqno(m:Int,n:Int): Int ={
    val s = "seq_exp=%d+%d"
    println(s.format(m,n))
    return m+n
  }
    val a = Array(1,2,3,4)
    val b = a.foldRight(5)(seqno)
    /** 运算过程
    seq_exp=4+5
    seq_exp=3+9
    seq_exp=2+12
    seq_exp=1+14
    */
    /**
    简写 (a :\ 5)(_+_)
    */

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

val a = Array(1,2,3,4)
val b = a.forall({x:Int=>x>0})    //true
val b = a.forall({x:Int=>x>2})   //false

36.foreach 重点！！！
def foreach(f: (A) ⇒ Unit): Unit
遍历序列中的元素，进行 f 操作

val a = Array(12,3,4,5)
a.foreach(x=>println(x*10))
res:120
30
40
50

37.group 重点！！！！！！不会基本无缘scala
groupBy
def groupBy[K] (f: (T) ⇒ K): Map[K, Array[T]]
按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列，下面代码实现的是，把小于3的数字放到一组，大于3的放到一组，返回Map[String,Array[Int]]

val k = Array(34,55,776,8,67)
//按照奇数和偶数

38.grouped
def grouped(size: Int): collection.Iterator[Array[T]]
指定数量分组，每组有size数量个元素，返回一个集合

val k = Array(34,55,776,8,67)
k.groupBy(3).foreach(x=>println(x.mkString(",")))
res:34,55,776
8,67

39.hasDefiniteSize
def hasDefiniteSize: Boolean
检测序列是否存在有限的长度，对应Stream这样的流数据，返回false

val k = Array(34,55,776,8,67)
k.hasDefiniteSize
res:Boolean = true

40.head
def head: T
返回序列的第一个元素，如果序列为空，将引发错误

val k = Array(34,55,776,8,67)
k.head
res:Int = 34

41.headOption
def headOption: Option[T]
返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None

var lst = ArrayBuffer()
lst.headOption
res:Option[Nothing] = None

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

​ def indexOf(elem: T, from: Int): Int
​ 返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回

​ indexOfSlice
​ def indexOfSlice[B >: A] (that: GenSeq[B]): Int
​ 检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引

val a = Array(1,3,2,3,4)
println(a.indexOf(3))       //return 1

val a = Array(1, 3, 2, 3, 4)
println(a.indexOf(3,2))    // return 3

val a = (1 to 20)
a: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
a.indexOfSlice(4 to 6)
res:Int = 3

43.indexWhere
def indexWhere(p: (T) ⇒ Boolean): Int
返回当前序列中第一个满足 p 条件的元素的索引

val a = (1 to 20)
a.indexWhere(p=>p>5)
res:Int = 5

44.indices
def indices: collection.immutable.Range
返回当前序列索引集合 取下标

val a  = (1 to 20)
a.indices
res:scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

45.init 重点！！！
def init: Array[T]
返回当前序列中不包含最后一个元素的序列（去尾）

val a  = (1 to 20)
a.init
res:scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

​ inits 重点！！！
​ def inits: collection.Iterator[Array[T]]
​ 对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

val a = Array(1, 2, 3, 4, 5)
    val b = a.inits.toList
    for(i <- 1 to b.length){
      val s = "第%d个值：%s"
      println(s.format(i,b(i-1).mkString(",")))
    }
    /**计算结果
    第1个值：1,2,3,4,5
    第2个值：1,2,3,4
    第3个值：1,2,3
    第4个值：1,2
    第5个值：1
    第6个值
    */

46.intersect
def intersect(that: collection.Seq[T]): Array[T]
取两个集合的交集

val a  = (1 to 20)
var b = (10 to 25)
a.intersect(b)
res:scala.collection.immutable.IndexedSeq[Int] = Vector(10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

47.isDefinedAt
def isDefinedAt(idx: Int): Boolean
判断序列中是否存在指定索引

var b = (10 to 25)
b.isDefinedAt(20)
res:Boolean = false

b.isDefinedAt(5)
res:Boolean = true

48.isEmpty
def isEmpty: Boolean
判断当前序列是否为空

import scala.collection.mutable.ArrayBuffer
val c = ArrayBuffer()
c.isEmpty
res:Boolean = true

49.isTraversableAgain
def isTraversableAgain: Boolean （看是不是迭代器----只能遍历一次）
判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写

var arr = Array(1,345,65,787,98)
arr.isTraversableAgain
res:Boolean = true

arr.iterator.isTraversableAgain
res:Boolean = false

50.last
def last: T
取得序列中最后一个元素

 val a = Array(1, 2, 3, 4, 5)
 println(a.last)          // return  5

51.lastIndexOf
def lastIndexOf(elem: T): Int
取得序列中最后一个等于 elem 的元素的位置

val a = Array(1, 4, 2, 3, 4, 5)
println(a.lastIndexOf(4))     // return  4

52.lastIndexOfSlice
def lastIndexOfSlice[B >: A] (that: GenSeq[B]): Int
判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引

​ def lastIndexOfSlice[B >: A] (that: GenSeq[B], end: Int): Int
​ 判断当前序列中是否包含序列 that，并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
println(a.lastIndexOfSlice(b))    // return  6


val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
val b = Array(1, 4)
println(a.lastIndexOfSlice(b,4))    // return  0

53.lastIndexWhere
def lastIndexWhere(p: (T) ⇒ Boolean): Int
返回当前序列中最后一个满足条件 p 的元素的索引

val a = Array(1, 4, 2, 3, 4, 5, 1, 4)
println(a.lastIndexWhere( {x:Int => x<2}))  // return  6

54.lastOption
def lastOption: Option[T]
返回当前序列中最后一个对象

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

55.length
def length: Int
返回当前序列中元素个数

val a = Array(1, 2, 3, 4, 5)
println(a.length)        // return  5

56.lengthCompare
def lengthCompare(len: Int): Int
比较序列的长度和参数 len，根据二者的关系返回不同的值，比较规则是
length-括号里面的数

val arr = Array(1, 2, 3, 4, 5)
arr.lengthCompare(3)
res:Int = 2
arr.lengthCompare(2)
res:Int = 3
arr.lengthCompare(7)
res:Int = -2
arr.lengthCompare(6)
res:Int = -1
arr.lengthCompare(5)
res:Int = 0

57.map 重点！！！
def map[B](f: (A) ⇒ B): Array[B] 遍历操作
对序列中的元素进行 f 操作
举个例子：

//怎么实现wordcount
val str = "hello mysql hello java"

str.split(" ").map(x=>(x,1)).groupBy(_._1).mapValues(_.size)
scala.collection.immutable.Map[String,Int] = Map(java -> 1, mysql -> 1, hello -> 2)

str.split(" ").map(x=>(x,1)).groupBy(_._1).foreach(x=>{println(x._1,x._2.length)})
res:(java,1)
(mysql,1)
(hello,2)

58.max
def max: A

var arr = Array(1, 345, 65, 787, 98)
arr.max
res:Int  =787

59.maxBy
def maxBy[B](f: (A) ⇒ B): A
返回序列中第一个符合条件的最大的元素

var arr = Array(1, 345, 65, 787, 98)
arr.maxBy(x=>x>100)
res:Int = 345

60.mkString
def mkString: String
将所有元素组合成一个字符串

​ def mkString(sep: String): String
​ 将所有元素组合成一个字符串，以 sep 作为元素间的分隔符

val a = Array(1, 2, 3, 4, 5)
println(a.mkString)           // return 12345

val a = Array(1, 2, 3, 4, 5)
println(a.mkString(","))     // return 1,2,3,4,5

61.nonEmpty
def nonEmpty: Boolean
判断序列不是空

var arr = Array(1, 345, 65, 787, 98)
arr.nonEmpty
res:Boolean = true

62.padTo
def padTo(len: Int, elem: A): Array[A] 补位
后补齐序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

var arr = Array(1, 345, 65, 787, 98)
arr.padTo(10,0)
res:Array[Int] = Array(1,345, 65, 787, 98, 0, 0, 0, 0, 0)

63.par 重点！！！
def par: ParArray[T]
返回一个并行实现，产生的并行序列，不能被修改

val a = Array(1, 2, 3, 4, 5)
val b = a.par         //"ParArray" size = 5

64.partition 重点！！！
def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分

var arr = Array(1, 345, 65, 787, 98)
arr.partition(_%2==0)
res:(Array[Int], Array[Int]) = (Array(98),Array(1, 345, 65, 787))

65.patch
def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that。

var arr = Array(1, 345, 65, 787, 98)
var arr1 = Array(1,2,3)
arr.patch(0,arr1,1)
res:Array[Int] = Array(1, 2, 3, 345, 65, 787, 98)

66.permutations
def permutations: collection.Iterator[Array[T]]
排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样。

var arr = Array(1, 345, 65, 787, 98)
arr.permutations.toList
res:List[Array[Int]] = List(Array(1, 345, 65, 787, 98), Array(1, 345, 65, 98, 787), Array(1, 345, 787, 65, 98), Array(1, 345, 787, 98, 65), Array(1, 345, 98, 65, 787), Array(1, 345, 98, 787, 65), Array(1, 65, 345, 787, 98), Array(1, 65, 345, 98, 787), Array(1, 65, 787, 345, 98), Array(1, 65, 787, 98, 345), Array(1, 65, 98, 345, 787), Array(1, 65, 98, 787, 345), Array(1, 787, 345, 65, 98), Array(1, 787, 345, 98, 65), Array(1, 787, 65, 345, 98), Array(1, 787, 65, 98, 345), Array(1, 787, 98, 345, 65), Array(1, 787, 98, 65, 345), Array(1, 98, 345, 65, 787), Array(1, 98, 345, 787, 65), Array(1, 98, 65, 345, 787), Array(1, 98, 65, 787, 345), Array(1, 98, 787, 345, 65), Array(1, 98, 787, 65, 345), Array(345, 1, 65, 787, 98), Array(345, 1, 65, 98, 787), Array(345, 1, 787, 65, 98), Array(345,...

arr.combinations(3).foreach(x=>println(x.mkString(",")))
res:1,345,65
1,345,787
1,345,98
1,65,787
1,65,98
1,787,98
345,65,787
345,65,98
345,787,98
65,787,98

67.prefixLength
def prefixLength(p: (T) ⇒ Boolean): Int
给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

var arr = Array(1, 345, 65, 787, 98)
arr.prefixLength(_<787)
res:Int = 3

68.product 重点！！！
def product: A
返回所有元素乘积的值

(1 to 5 ).product
res:Int = 120

(1 to 5 ).sum
res:Int = 15

69.reduce
def reduce[A1 >: A] (op: (A1, A1) ⇒ A1): A1
同 fold，不需要初始值

var arr = Array(1, 345, 65, 787, 98)
arr.reduce(_+_)
res:Int = 1296

def reduceLeft[B >: A] (op: (B, T) ⇒ B): B
从左向右计算

def reduceRight[B >: A] (op: (T, B) ⇒ B): B
从右向左计算

def reduceLeftOption[B >: A] (op: (B, T) ⇒ B): Option[B]
计算Option，参考reduceLeft

def reduceRightOption[B >: A] (op: (T, B) ⇒ B): Option[B]
计算Option，参考reduceRight

70.reverse
def reverse: Array[T]
反转序列

val arr = Array(1,2,3,4,5)
arr.reverse
res:Array[Int] = Array(5, 4, 3, 2, 1)

71.reverseIterator
def reverseIterator: collection.Iterator[T]
反向生成迭代

val arr = Array(1,2,3,4,5)
arr.reverseIterator.foreach((x:Int)=>print(x))
res:54321

72.reverseMap
def reverseMap[B](f: (A) ⇒ B): Array[B]
同 map 方向相反

var arr = Array(1, 345, 65, 787, 98)
arr.reverseMap((_,1))
res:Array[(Int, Int)] = Array((98,1), (787,1), (65,1), (345,1), (1,1))

73.sameElements
def sameElements(that: GenIterable[A]): Boolean
判断两个序列是否顺序和对应位置上的元素都一样

var arr = Array(1, 345, 65, 787, 98)
val arr2 = arr.clone
arr.sameElements(arr2)
res:Boolean = true

74.scan 重点！！！
def scan[B >: A, That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值

​ scanLeft
​ def scanLeft[B, That] (z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
​ 从左向右计算

​ scanRight
​ def scanRight[B, That] (z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
​ 从右向左计算

val a = Array(1,2,3,4,5)
val b = a.scan(5)(seqno)
println(b.mkString(","))          // 5,6,8,11,15,20

val input = List(3, 5, 7, 11)
input.scanLeft(0)(_+_)
res:List[Int] = List(0, 3, 8, 15, 26)

75.segmentLength
def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

var arr = Array(1, 345, 65, 787, 98)
arr.segmentLength(_<500,1)
res:Int = 2

76.seq
def seq: collection.mutable.IndexedSeq[T]
产生一个引用当前序列的 sequential 视图

var arr = Array(1, 345, 65, 787, 98)
arr.seq
res:scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 345, 65, 787, 98)

77.size
def size: Int
序列元素个数，同 length

var arr = Array(1, 345, 65, 787, 98)
arr.size
res:Int = 5

78.slice
def slice(from: Int, until: Int): Array[T]
取出当前序列中，from 到 until 之间的片段

var arr = Array(1, 345, 65, 787, 98)
arr.slice(1,4)
res:Array[Int] = Array(345, 65, 787)

79.sliding
def sliding(size: Int): collection.Iterator[Array[T]]
从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

​ def sliding(size: Int, step: Int): collection.Iterator[Array[T]]
​ 从第一个元素开始，每个元素和他后面的size-1个元素组成一个数组，最终组成和一个新的集合返回，当剩余元素不够size数，则停止
该方法可以设置步长step，第一个元素组合完成后，下一个从上一个元素位置+step后的位置处元素开始

var arr = Array(1, 345, 65, 787, 98)
arr.sliding(3).foreach(x=>println(x.mkString(",")))
res:1,345,65
345,65,787
65,787,98、


arr.sliding(3,3).foreach(x=>println(x.mkString(",")))
res:1,345,65
787,98
//可以加步长 记一次之后跳步长接着计数

80.sortBy
def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
按指定的排序规则排序

var arr = Array(1, 345, 65, 787, 98)
//升序
arr.sortBy(x=>x)
res:Array[Int] = Array(1,65,98,345,787)

//降序
arr.sortBy(x=>0-x)
res:Array[Int] = Array(787, 345, 98, 65, 1)

81.sortWith
def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
自定义排序方法 lt

val arr = Array("hello","world","are")
arr.sortBy(x=>x)
res:Array[String] = Array(are, hello, world)

def mycomp(x:Any,y:Any):Boolean ={
	x+"" > y+""
}
var arr1 = Array("hello","world",20,"are","abc")
arr.sortWith(mycomp)
res:Array[Any] = Array(world, hello, are, abc, 20)

82.sorted
def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
使用默认的排序规则对序列排序

val a = Array(3,2,1,4,5)
val b = a.sorted    
println(b.mkString(","))         // 1,2,3,4,5

83.span 重点！！！
def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合

var arr1 = Array("hello","world",20,"are","abc")
arr1.span(_.isInstanceOf[String])
res:(Array[Any], Array[Any]) = (Array(hello,world,are),Array(20, abc))

//当碰到不满足的开始 后面所有的都放到另一个数组

84.splitAt 重点！！！
def splitAt(n: Int): (Array[T], Array[T])
从指定位置开始，把序列拆分成两个集合

var arr1 = Array("hello","world",20,"are","abc")
arr1.splitAt(3)
res:(Array[Any], Array[Any]) = (Array(hello,world,are),Array(20, abc))

85.startsWith
def startsWith[B] (that: GenSeq[B], offset: Int): Boolean
从指定偏移处，是否以某个序列开始
def startsWith[B] (that: GenSeq[B]): Boolean
是否以某个序列开始

var arr1 = Array("hello","world",20,"are","abc")
val t1 = Array("world","are")
arr1.startsWith(t1)
res:Boolean = false

arr1.startsWith(t1,1)
res:Boolean = true

86.stringPrefix
def stringPrefix: String
返回 toString 结果的前缀

"abcd".stringPrefix
res:String = String

87.subSequence
def subSequence(start: Int, end: Int): CharSequence
返回 start 和 end 间的字符序列

val chars = Array('a','b','c','d')
val b = chars.subSequence(1,3)
res:b: CharSequence = bc

88.sum
def sum: A
序列求和，元素需为Numeric[T]类型

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

89.tail
def tail: Array[T]
返回除了当前序列第一个元素的其它元素组成的序列(去头)

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

90.take 重点！！！
def take(n: Int): Array[T]
返回当前序列中前 n 个元素组成的序列

var arr1 = Array("hello","world",20,"are","abc")
arr1.take(3)
res:Array[Any] = Array(hello, world, 20)

91.takeRight
def takeRight(n: Int): Array[T]
返回当前序列中，从右边开始，选择 n 个元素组成的序列

var arr1 = Array("hello","world",20,"are","abc")
arr1.takeRight(3)
res:Array[Any] = Array(20,are,abc)

92.takeWhile
def takeWhile(p: (T) ⇒ Boolean): Array[T]
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

val s1 = Array(1,2,3,4,10,20,30,40,5,6,7,8,50,60,70,80)
s1.takeWhile(_<10)
res:Array[Int] = Array(1,2,3,4)

转换类型：

93.toArray
def toArray: Array[A]
转换成 Array 类型

val a = List(1,2,3)
a.toArray
res:Array[Int] = Array(1, 2, 3)

94.toBuffer
def toBuffer[A1 >: A]: Buffer[A1]
转换成 Buffer 类型 将不可变转变为可变

val b = Array(1,2,3)
b.toBuffer
res:scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3)

95.toIndexedSeq
def toIndexedSeq: collection.immutable.IndexedSeq[T]
转换成 IndexedSeq 类型（序列）

val b = Array(1,2,3)
b.toIndexedSeq
res:scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3)

96.toIterable
def toIterable: collection.Iterable[T]
转换成可迭代的类型

val b = Array(1,2,3)
b.toIterable
res:Iterable[Int] = WrappedArray(1, 2, 3)

97.toList
def toList: List[T]
转换为 List 类型

val b = Array(1,2,3)
b.toList
res: List[Int] = List(1, 2, 3)

98.toMap
def toMap[T, U]: Map[T, U]
转换为 Map 类型，需要被转化序列中包含的元素时 Tuple2 类型数据

val chars = Array(("a","b"),("c","d"),("e","f"))
val b = chars.toMap
println(b)            //Map(a -> b, c -> d, e -> f)

99.toSeq
def toSeq: collection.Seq[T]
转换为Seq 类型

val b = Array(1,2,3)
b.toSeq
res: Seq[Int] = WrappedArray(1, 2, 3)

100.toSet
def toSet[B >: A]: Set[B]
转换为Set 类型

val b = Array(1,2,3)
b.toSet
res: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

101.toStream
def toStream: collection.immutable.Stream[T]
转换为Stream 类型

val b = Array(1,2,3)
b.toStream
res:scala.collection.immutable.Stream[Int] = Stream(1, ?)

102.toVector
def toVector: Vector[T]
转换为Vector 类型

val b = Array(1,2,3)
b.toVector
res:Vector[Int] = Vector(1, 2, 3)

103.transpose
def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
矩阵转换，二维数组行列转换

val ar = Array(Array(3,4,5),Array(7,8,9),Array(10,11,12))
ar.transpose
res: Array[Array[Int]] = Array(Array(3, 7, 10), Array(4, 8, 11), Array(5, 9, 12))

104.union
def union(that: collection.Seq[T]): Array[T]
联合两个序列，同操作符 ++

val b = Array(1,2,3)
val c = Array(4,5,6)
val d = b.union(c)
res:Array[Int] = Array(1, 2, 3, 4, 5, 6)

105.unzip
def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列

val arr = Array((1,2),(3,4),(5,6),(7,8))
arr.unzip
res:(Array[Int], Array[Int]) = (Array(1,3,5,7),Array(2,4,6,8))

//注意子元素只能有两个元素 超过2个或者1个都不能使用这个方法 

106.unzip3
def unzip3[T1, T2, T3] (implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

val arr1 = Array((1,2,3),(4,5,6),(7,8,9))
arr1.unzip3
res:(Array[Int], Array[Int], Array[Int]) = (Array(1, 4, 7),Array(2, 5, 8),Array(3, 6, 9))

107.update
def update(i: Int, x: T): Unit
将序列中 i 索引处的元素更新为 x

var arr = Array(23,654,756,312)
arr.update(1,61)
res: Array(23,61,756,312)

108.updated
def updated(index: Int, elem: A): Array[A]
将序列中 i 索引处的元素更新为 x ,并返回替换后的数组

var arr = Array(23,654,756,312)
arr.update(1,61)
res: Array(23,61,756,312)
arr:Array[(Int,Int)] = Array(23,654,756,312)
//不改变原数组的值 可以用新的数组来接这个值

109.view
def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
返回 from 到 until 间的序列，不包括 until 处的元素

var arr1 = Array("hello","world",20,"are","abc")
arr1.view(1,3)
res: arr1.view(1,3).foreach(x=>println(x))
world
20

110.withFilter
def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
根据条件 p 过滤元素

val a = Array(1,2,3,4,5)
a.withFilter(_>3).map(x=>x)
res: Array[Int] = Array(4,5)

111.zip
def zip[B] (that: GenIterable[B]): Array[(A, B)]
将两个序列对应位置上的元素组成一个pair序列 和unzip相对

val t1 = Array(world,are)
val t2 = Array(are,20)
t1.zip(t2)
res:Array[(String, Any)] = Array((world,are), (are,20))

val t3 = Array(1,2,3,4,5)
t3.zip(t1)
res:Array[(Int, String)] = Array((1,world), (2,are))

112.zipAll
def zipAll[B] (that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
zipAll 函数和上面的zip函数类似，但是如果其中一个元素个数比较少，那么将用默认的元素填充

val a = Array(1,2,3,4,5,6,7)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,9,8)     //(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)
 
val a = Array(1,2,3,4)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,9,8)      //(1,5),(2,4),(3,3),(4,2),(9,1)

113.zipWithIndex
def zipWithIndex: Array[(A, Int)]
序列中的每个元素和它的索引组成一个序列

val a = Array(10,20,30,40)
val b = a.zipWithIndex
println(b.mkString(","))       //(10,0),(20,1),(30,2),(40,3)