一、Scala中Array数组

1.定义

定义：数组是一种可变的、可索引的数据集合。

2.语法格式

语法格式：Scala中用Array[T]的形式来表示Java中的数组形式 T[]

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

二、Scala：Array的集合操作

1. ++ ++：

1.1 ++

语法：def ++[B](that: GenTraversableOnce[B]): Array[B]
注解：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。

 val a = Array(1,2)val b = Array(3,4)val c = a ++ bc	//结果：Array[Int] = Array(1, 2, 3, 4)val b = Array("c","d")val c = a ++ b		//c: Array[Any] = Array(1, 2, c, d)

1.2 ++：

语法：def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
注解：合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容，且右边操作数据的类型决定着返回结果的类型（不是值类型）。
举例**：
下面代码中List和LinkedList结合，返回结果是LinkedList类型

val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass().getName())// c的类型是：scala.collection.mutable.LinkedList

2. +： :+

2.1 +:

语法：def +:(elem: A): Array[A]
注解：在数组前面添加一个元素，并返回新的对象
举例**：下面添加一个元素 0

 val a = List(1,2)val c = 0 +: a // c中的内容是 （0,1,2）

2.2 :+

语法：def :+(elem: A): Array[A]
注解：在数组末尾添加一个元素，并返回新对象

 val a = List(1,2)val c = a :+ 0 // c中的内容是 （1,2,0）

3. /: :\

3.1 /:

语法：def /:[B](z: B)(op: (B, T) ⇒ B): B
注解：对数组中所有的元素进行相同的操作 ，foldLeft的简写（左二叉树）

 val a = List(1,2,3,4)val c = (10 /: a)(_+_)   // 1+2+3+4+10val d = (10 /: a)(_*_)   // 1*2*3*4*10println("c:"+c)   // c:20println("d:"+d)   // d:240

3.2 :\

语法：def :[B](z: B)(op: (T, B) ⇒ B): B
注解：对数组中所有的元素进行相同的操作 ，foldRight的简写（右二叉树）

4. addString

4.1 addString(b: StringBuilder)

语法：def addString(b: StringBuilder): StringBuilder
注解：将数组中的元素逐个添加到b中

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b)   // c中的内容是  1234

4.2 addString(b: StringBuilder, sep: String)

语法： def addString(b: StringBuilder, sep: String): StringBuilder
注解：将数组中的元素逐个添加到b中，但每个元素间sep分隔符分开

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,",") 
println("c:  "+c)  // c:  1,2,3,4

4.3 addString(b: StringBuilder, start: String, sep: String, end: String)

语法：def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
注解：将数组中的元素逐个添加到b中，同时在首尾各加一个字符串，并指定sep分隔符

val a = List(1,2,3,4)
val b = new StringBuilder()
val c = a.addString(b,"{",",","}") 
println("c:  "+c)  // c:  {1,2,3,4}

5. aggregate

语法：def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
注解：聚合计算，aggregate是柯里化方法，参数是两个方法。
举例**：为方便理解，我们把aggregate的两个参数，分别封装成两个方法，并把计算过程打印出来。

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
}def main(args: Array[String]) {val a = List(1,2,3,4)val c = a.par.aggregate(5)(seqno,combine)println("c:"+c)
}
/**seq_exp=5+3seq_exp=5+2seq_exp=5+4seq_exp=5+1com_exp=6+7com_exp=8+9com_exp=13+17c:30
*/def mapper(m:Int,n:Int): Int ={val s = "seq_exp=%d+%d"println(s.format(m,n))return m+n
}
def reducer(m:Int,n:Int): Int ={val s = "com_exp=%d+%d"println(s.format(m,n))return m+n
}
def main(args: Array[String]) {val a = List(1,2,3,4,5)val c = a.par.aggregate(5)(seqno,combine)println("c:"+c)
}
/**第一个方法产生的结果集个数为奇数，会产生轮空。seq_exp=5+3seq_exp=5+2seq_exp=5+5seq_exp=5+4seq_exp=5+1com_exp=6+7com_exp=8+9com_exp=13+10com_exp=23+17c:40
*/

上面过程可以简写为

val a = List(1,2,3,4,5)
val c = a.par.aggregate(5)(_+_,_+_)	//c:Int = 40
println(c)	//40

6. andThen compose

6.1 andThen

语法：def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) }
注解：Composes two instances of Function1 in a new Function1, with this function applied first.
@tparam A the result type of function g
@param g a function R => A
@return a new function f such that f(x) == g(apply(x))
andThen是实现一个新的函数f(x) ==g(apply(x))，本质是构建一个新的函数先运行g再运行f
例：

6.2 compose

语法：def compose[A](g: A => T1): A => R = { x => apply(g(x)) }
注解：Composes two instances of Function1 in a new Function1, with this function applied last.
@tparam A the type to which function g can be applied
@param g a function A => T1
@return a new function f such that `f(x) == apply(g(x))``
compose是实现一个新的函数f(x) == apply(g(x))，本质是构建一个新的函数先运行f再运行g
例：

对比测试

/** * 传入Int,结果翻倍 */
val doubleNum :Int => Int  = {num =>val numDouble = num * 2println(s"double Num ($num * 2 = $numDouble)")numDouble
}
// doubleNum: Int => Int = <function1>/** *传入Int,结果加一 */
val addOne:Int => Int = {num=>val sumNum = num + 1println(s"add One ($num + 1 = $sumNum)")sumNum
}
addOne: Int => Int = <function1>

def myAndThen[A, B, C](g: A => B, f: B => C): A => C = x => f(g(x))
// myAndThen: [A, B, C](g: A => B, f: B => C)A => C
def myCompose[A, B, C](g: A => B, f: C => A): C => B = x => g(f(x))
// myCompose: [A, B, C](g: A => B, f: C => A)C => B

andThen：
期待一个A类型转化成一个C类型，x是一个A类型，将x传给g，作为g的参数得到一个一个B类型，再将结果作为参数传给f，f在是将B类型转化为一个C类型，最终实现A类型的x转化为C类型。
compose：
期待一个C类型转化为B类型，也就是是说compose则是将先执行靠里面的函数，再将结果传给外层函数，所以先执行f将C类型的x转化为一个A类型，再作为参数传给g，得到一个B类型。

val myComposeTest = myCompose[Int, Int, Int](addOne, doubleNum)	//myComposeTest: Int => Int = <function1>
myComposeTest(2)
val composeDoubleNumInAddOne = addOne compose doubleNum
val composeAddOneInDoubleNum = doubleNum compose addOne
composeDoubleNumInAddOne(2)
composeAddOneInDoubleNum(2)
assert(myComposeTest(2)==composeDoubleNumInAddOne(2))val myAndThenTest = myAndThen[Int,Int,Int](addOne,doubleNum)
myAndThenTest(2)
val addOneAndThenDoubleNum = addOne andThen doubleNum
val doubleNumAndThenAddOne = doubleNum andThen addOne
addOneAndThenDoubleNum(2)
doubleNumAndThenAddOne(2)
assert(myAndThenTest(2)==addOneAndThenDoubleNum(2))

7. apply

7.1 apply

语法: def apply(i: Int): T
注解：取出指定索引i处的元素
例：

val a = Array(1,3,4,6)
val b = a.apply(2)
println("b=" + b)    // 结果：b=4
// 等同于
val b = numbers(2) 
println("b=" + b)    // 结果：b=4

7.2 applyOrElse

语法：def applyOrElse[A1 <: Int, B1 >: Int](x: A1,default: A1 => B1): B1
注释： 取出指定索引x处的元素，如果不存在索引x，则提供一个函数，指定默认值
例：

val a = Array(1,3,6,2,4,8)
val b = a.applyOrElse(1,{x:Int => 9})	// b: Int = 3
val b = a.applyOrElse(6,{x:Int => 9})	// b: Int = 9val b = a.applyOrElse(6,{x:String => "a"'})	// error: type mismatch;

8. array

语法：
注释：创建数组方法
例：

9. canEqual

语法：def canEqual(that: Any): Boolean
注释：判断两个对象是否可以进行比较
注意：这个方法基本不用，因为一般都能比较

10. charAt

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

val chars = Array('a','b','c')
println("c:"+chars.charAt(0))   //结果 aval a = Array(1,3,4,6)
val d = a.charAt(0)	// 报错

11. clone（浅克隆）

语法： def clone(): Array[T]
注解：基于当前对象，创建一个副本
例：

 val chars = Array('a','b','c')  // (a,b,c)val newchars = chars.clone()
newchars  // (a,b,c)

12. collect collectFirst

12.1 collect

语法：def collect[B](pf: PartialFunction[A, B]): Array[B]
注释：通过执行一个并行计算（偏函数），得到一个新的数组对象
例：

val a = Array(1,2,3,4)
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case x => x+1
}
a.collect(func)	// 结果：Array：Int = Array(2,4,4,6)
a.collectFirst(func)	//结果：Option[Int] = Some(4)// fun偏函数的case变式
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
case _ => 1
}
a.collect(func)	//结果：Array：Int = Array(1,4,1,6)# fun偏函数的case变式
val func:PartialFunction[Int,Int]={
case x if x%2==0 => x+2
}
a.collect(func)	//结果：Array：Int = Array(4,6)

12.2 collectFirst

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

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

13. combinations

语法： def combinations(n: Int): collection.Iterator[Array[T]]
注解：排列组合，这个排列组合会选出所有包含字符不一样的组合，（对于 “abc”、“cba”，只选择一个），参数n表示序列长度，即几个元素为一个组合
例：

val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newwarr.foreach(println)	//结果：3个地址值
newarr.foreach((item) => println(item.mkString(",")))
/**
结果：
a,b
a,c
b,c
*/

14. companion（伴生对象）

语法：override def companion: scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq]
注解：
例：

val d = Array（1,3,3,2,4）
val f = d.companion		//f:scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = scala.collection.mutable.IndexedSeq$@3bf7c70e
println(f)		// scala.collection.mutable.IndexedSeq$@3bf7c70e

15. contains containsSlice

15.1 contains

语法： def contains[A1 >: A](elem: A1): Boolean
注解：判断序列中是否包含指定对象（次序一致）

15.2 containsSlice

语法：def containsSlice[B](that: GenSeq[B]): Boolean
注解： [slaɪs]判断当前序列中是否包含另一个序列

val b = Array(1,2,3,Array(4,5))
val c = Array(4,5,6)
b.containsSlice(c)	// 结果：Boolean = falseval c = Array(4,5)
b.containsSlice(c)	// 结果：Boolean = false
val b = Array(1,2,3,4,5)
b.containsSlice(c)	// 结果：Boolean = true

16. copy

16.1 copyToArray

语法1**：def copyToArray(xs: Array[A]): Unit
注解1**：将元数组中的元素拷贝到新数组，默认拷贝元数组所有元素

语法2**：def copyToArray(xs: Array[A], start: Int): Unit
注解2**：将元数组中的元素拷贝到新数组，从新数组索引为start的地方开始写入，默认拷贝元数组所有元素

语法3**：def copyToArray(xs: Array[A], start: Int, len: Int): Unit
注解3**：将元数组中的元素拷贝到新数组，从新数组索引为start的地方开始写入，拷贝元数组元素长度为len

val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)	//结果：b: Array[Char] = Array(?, ?, ?, ?, ?)
a.copyToArray(b)    
b // 结果：res34: Array[Char] = Array(a, b, c, ?, ?)val b : Array[Char] = new Array(5)
a.copyToArray(b,1)
b // 结果：res38: Array[Char] = Array(?, a, b, c, ?)val b : Array[Char] = new Array(5)
a.copyToArray(b,1,2)
b // 结果：res43: Array[Char] = Array(?, a, b, ?, ?)

16.2 copyToBuffer

语法：def copyToBuffer[B >: A](dest: Buffer[B]): Unit
注解：将数组中的内容拷贝到Buffer中
例：

val a = Array('a', 'b', 'c')
import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Char]()
// 或者  val b:ArrayBuffer[Char]  = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))	//结果：a,b,c

17. corresponds

语法：def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
注解：[ˌkɒrəˈspɒndz]；判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true；否则，返回false（元素数量不同，返回false）
例：下面代码检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素

val a = Array(1, 2, 3)
val b = Array(4, 5,6)
println(a.corresponds(b)(_<_))  //结果：true

18. count

语法：def count(p: (T) ⇒ Boolean): Int
注解：统计符合条件的元素个数
例：下面统计大于 2 的元素个数

val a = Array(1, 2, 3)
println(a.count({x:Int => x > 2}))  // Int = 1val e = Array("Hello","world","hadoop")
e.count(x=>x.contains("o"))
e.count(x=>x.indexOf("o")!= -1)	//Int = 3

18. deep

语法：def deep: IndexedSeq[Any]
注解：将提供序列转型为IndexedSeq[Any]类型，序列值类型自动提升
例：

val a = Array(1,2,4,3)		//a: Array[Int] = Array(1, 2, 4, 3)
val b = a.deep		//b: IndexedSeq[Any] = Array(1, 2, 4, 3)
println(a)		//[I@2ac5ba7a
println(b)		//Array(1, 2, 4, 3)

19. diff

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

val a = Array(1, 2, 3,4)
val b = Array(4, 5,6,7)
val c = a.diff(b)
println(c.mkString) //1,2,3

20. distinct

语法：def distinct: Array[T]
注解：去除当前集合中重复的元素，只保留一个
例：

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

21. drop

21.1 drop(n: Int)

语法：def drop(n: Int): Array[T]
注解：将当前序列中前 n 个元素去除后，作为一个新序列返回
例：

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

21.2 dropRight(n: Int)

语法：def dropRight(n: Int): Array[T]
注解：将当前序列中尾部 n 个元素去除后，作为一个新序列返回
例：

val a = Array(1, 2, 3,4)
val c = a.dropRight(2)
println(c.mkString(","))    // 结果：1,2

21.3 dropWhile(p: (T) ⇒ Boolean)

语法：def dropWhile(p: (T) ⇒ Boolean): Array[T]
注解：去除当前数组中符合条件的元素（从当前数组的第一个元素起，直到碰到第一个不满足条件的元素结束，否则返回整个数组）
例：

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

22. elemMainfest

语法：def elemManifest: ClassManifest[AI]
注解：
例：

val a = Array(1,2,3,4,5)
val b = a.elemManifest	// b:ClassManifest[Int] = Int
println(b)		// Intval a = Array(1,2,3,"a")
val b = a.elemManifest	// b: ClassManifest[Any] = java.lang.Object
println(b)		// java.lang.Object

23. elemTag

语法：def elemTag: scala.reflect.ClassTag[A1]
注解：
例：

val a = Array(1,2,3,4,5)
val b = a.elemTag	// scala.reflect.ClassTag[Int] = Int
println(b)		// Intval a = Array(1,2,3,"a")
val b = a.elemTag	// b: scala.reflect.ClassTag[Any] = Object
println(b)		// Object

24. endsWith

语法：def endsWith[B](that: GenSeq[B]): Boolean
注解：判断是否以某个序列结尾
例：

val a = Array(3, 2, 3,4)
val b = Array(3,4)
println(a.endsWith(b))  // 结果：true

25. exists

语法：def exists(p: (T) ⇒ Boolean): Boolean
注解： 判断当前数组是否包含符合条件的元素
例：

val a = Array(3, 2, 3,4)
println(a.exists( {x:Int => x==3} ))   //true
println(a.exists( {x:Int => x==30} ))  //false

26. filter filterNot

26.1 filter

语法：def filter(p: (T) ⇒ Boolean): Array[T]
注解：取得当前数组中符合条件的元素，组成新的数组返回
例：

val a = Array(3, 2, 3,4)
val b = a.filter( {x:Int => x> 2} )  
// 等价val b = a.filter(x => x>2)	和	val b = a.filter(_ > 2)
println(b.mkString(","))    //3,3,4

26.2 filterNot

语法：def filterNot(p: (T) ⇒ Boolean): Array[T]
注解：取得当前数组中不符合条件的元素，组成新的数组返回
例：

val a = Array(3, 2, 3,4)
val b = a.filterNot( {x:Int => x> 3} )
println(b.mkString(","))    //3,2,3

27. find

语法：def find(p: (T) ⇒ Boolean): Option[T]
注解：查找第一个符合条件的元素
例：

val a = Array(1, 2, 3,4)
val b = a.find( {x:Int => x>2} )
println(b)  // 结果：Some(3)
b.get	//结果：Int=3

28. flatMap flatten

28.1 flatMap

语法：def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
注解： 先执行Map对当前序列的每个元素进行操作，后执行flat将map后的结果放入新序列返回，参数要求是GenTraversableOnce及其子类
例：

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
*/

27.2 flatten

语法：def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
注解： 将二维数组的所有元素联合在一起，形成一个一维数组返回（要求数组中元素的维度保持一致，否则报错）
例：

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

29. fold

29.1 fold

语法：def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
注解：对序列中的每个元素进行二元运算
区分aggregate：fold同aggregate有类似的语义，但执行过程有所不同（aggregate需要两个处理方法）
例：

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
}val a = Array(1, 2, 3,4)val b = a.fold(5)(seqno)/** 运算过程seq_exp=5+1seq_exp=6+2seq_exp=8+3seq_exp=11+4*/val c = a.par.aggregate(5)(seqno,combine)/** 运算过程seq_exp=5+1seq_exp=5+4seq_exp=5+3com_exp=8+9seq_exp=5+2com_exp=6+7com_exp=13+17*/

fold中，seqno是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算
aggregate中，seqno是把初始值与每个元素相加，但结果不参与下一步运算，而是放到另一个序列中，由第二个方法combine进行处理

29.2 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)(_+_)
*/

29.3 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+5seq_exp=3+9seq_exp=2+12seq_exp=1+14*//**简写 (a :\ 5)(_+_)*/

30. forall foreach

30.1 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

30.2 foreach

语法：def foreach(f: (A) ⇒ Unit): Unit
注解：遍历序列中的元素，进行 f 操作
例：

val a = Array(1, 2, 3,4)
a.foreach(x => println(x*10))
/**
10
20
30
40
*/

31. genericBuilder

语法：def genericBuilder[B]: scala.collection.mutable.Builder[B,scala.collection.mutable.IndexedSeq[B]]
注解：
例：

32. groupBy grouped

32.1 groupBy

语法：def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
注解：按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列。（条件最多23个）
例：下面代码实现的是，把小于3的数字放到一组，大于3的放到一组，返回Map[String,Array[Int]]

val a = Array(1, 2, 3,4)
val b = a.groupBy( x => x match {case x if (x < 3) => "small"case _ => "big"
})
//结果：Map(small -> Array(1,2,3), big -> Array(4))//取small的值
b.apply("small")	// Array(1,2,3)
或
b.get("small")	//Some(地址值)
b.get("small").get	// Array(1,2,3)// 分组后，取分组内的值
b.apply("small").apply(0)	//结果：Int = 1// 统计单词数量
val words = Array("hello world","hello scala","spark scala")
val word = words.flatMap(x => x.split(" "))  //val word = words.flatMap(_.split(" "))
word.groupBy(x=>x).foreach(f=>println(f._1,f._2.length))
/** 结果
(spark,1)
(scala,2)
(world,1)
(hello,2)
*/

32.2 grouped

语法：def grouped(size: Int): collection.Iterator[Array[T]]
注解：按指定数量将序列分为2组，每组有 size 数量个元素，返回一个集合(若序列元素数量 > size*2，则超出的元素不参与分组)
例：

val a = Array(1, 2, 3,4,5)
val b = a.grouped(3).toList
b.foreach((x) => println("第"+(b.indexOf(x)+1)+"组:"+x.mkString(",")))
/**
第1组:1,2,3
第2组:4,5
*/val e = Array(1,3,2,4,7,5,4)
val b = a.grouped(2)
b.foreach(x => println(x.mkString(",")))
//结果：1,32,4

33. hasDefiniteSize

语法：def hasDefiniteSize: Boolean
注解：检测序列是否存在有限的长度，对应Stream这样的流数据，返回false
例：

val a = Array(1, 2, 3,4,5)
println(a.hasDefiniteSize)  //true

34. head headOption

34.1 head

语法：def head: T
注解：返回序列的第一个元素，如果序列为空，将引发错误
例：

val a = Array(1, 2, 3,4,5)
println(a.head) //Int = 1

34.2 headOption

语法：def headOption: Option[T]
注解：返回Option类型对象，（scala.Some 或者 None）如果序列是空，返回None
例：

val a = Array(1, 2, 3,4,5)
println(a.headOption)   //Some(1)val a:Array[Int] = Array()
println(a.headOption)   //None

35. indexOf

35.1 indexOf(elem: T)

语法：def indexOf(elem: T): Int
注解：返回elem在序列中的索引，找到第一个就返回索引值，找不到返回-1
例：

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

35.2 indexOf(elem: T, from: Int)

语法：def indexOf(elem: T, from: Int): Int
注解：返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回索引值，找不到返回-1
例：

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

35.3 indexOfSlice

语法：def indexOfSlice[B >: A](that: GenSeq[B]): Int
注解：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引,找不到返回-1
例：

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

语法：def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
注解：检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始，找不到返回-1
例：

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

35.4 indexWhere

语法1：def indexWhere(p: (T) ⇒ Boolean): Int
注解1：返回当前序列中第一个满足 p 条件的元素的索引
例：

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

语法2：def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
注解2：返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始
例：

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

36. indices

语法：def indices: collection.immutable.Range
注解：返回当前序列索引集合（对Map无效）
例：

val a = Array(10, 2, 3, 40, 5)
val b = a.indices	//Range（0,1,2,3,4）
println(b.mkString(","))    // 0,1,2,3,4

37. init inits

37.1 init

语法：def init: Array[T]
注解：返回当前序列中不包含最后一个元素的序列
例：

val a = Array(10, 2, 3, 40, 5)
val b = a.init
println(b.mkString(","))    // 10, 2, 3, 40

37.2 inits

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

val a = Array(1, 2, 3, 4, 5)
val b = a.inits.toList
b	// b: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())
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个值
*/val e = Array(1,2,3)
e.inits.foreach(x => println(x,,mkString(",")))
// 结果: 	
1,2,3
1,2
1

38. intersect

语法：def intersect(that: collection.Seq[T]): Array[T]
注解： [ˌɪntəˈsekt]；取两个集合的交集
例：

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

39. isDefinedAt

语法：def isDefinedAt(idx: Int): Boolean
注解: 判断序列中是否存在指定索引
例：

val a = Array(1, 2, 3, 4, 5)
println(a.isDefinedAt(1))   // true
println(a.isDefinedAt(10))  // false

40. isEmpty

语法：def isEmpty: Boolean
注解：判断当前序列是否为空

41. isTraversableAgain

语法：def isTraversableAgain: Boolean
注解：判断序列是否可以反复遍历(迭代器不能反复遍历，即判断是否是迭代器)
（该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写）

42. iterator

语法：def iterator: collection.Iterator[T]
注解：对序列中的每个元素产生一个 iterator（任何集合都有iterator方法）
例：

val a = Array(1, 2, 3, 4, 5)
val b = a.iterator  //此时就可以通过迭代器访问 b

43. last

43.1 last

语法：def last: T
注解：取得序列中最后一个元素
例：

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

43.2 lastIndexOf

语法1：def lastIndexOf(elem: T): Int
注解1：取得序列中最后一个等于 elem 的元素的位置，索引值
例：

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

语法2：def lastIndexOf(elem: T, end: Int): Int
注解2:取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前的元素（包括end）中查找
例：

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

43.3 lastIndexOfSlice

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

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

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

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

43.4 lastIndexWhere

语法1：def lastIndexWhere(p: (T) ⇒ Boolean): Int
注解1：返回当前序列中最后一个满足条件 p 的元素的索引
例：

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

语法2：def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
注解2：返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找
例：

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

44. lastOption

语法：def lastOption: Option[T]
注解：返回当前序列中最后一个对象，若序列为空，返回None
例：

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

45. length lengthCompare

45.1 length

语法：def length: Int
注解：返回当前序列中元素个数
例：

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

45.2 lengthCompare

语法：def lengthCompare(len: Int): Int
注解：比较序列的长度和参数 len，根据二者的关系返回不同的值，比较规则是
x < 0 if this.length < len
x == 0 if this.length == len
x > 0 if this.length > len
结果：this.length - len
例：

val e = Array（1,2,3）
e.lengthCompare(3)	//结果：0
e.lengthCompare(5)	//结果：-2

46. lift

语法：def lift: A1 => Option[B1]
注解：
例：

val a = Array(1,2,3)
val b = a.lift		//b: Int => Option[Int] = <function1>val a = Array(1, 2, 3, "a")	//a: Array[Any] = Array(1, 2, 3, a)
val b = a.lift		//b: Int => Option[Any] = <function1>

47. map

语法：def map[B](f: (A) ⇒ B): Array[B]
注解：对序列中的元素进行 f 操作
例：

val a = Array(1, 2, 3, 4, 5)
val b = a.map( {x:Int => x*10})
println(b.mkString(","))    // 10,20,30,40,50

48. max min

48.1 max

语法：def max: A
注解：返回序列中最大的元素
例：

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

48.2 maxBy

语法：def maxBy[B](f: (A) ⇒ B): A
注解：返回序列中第一个符合条件的元素
例：

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

48.3 min

语法：def min: A
注解：返回序列中最小的元素
例：

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

48.4 minBy

语法：def minBy[B](f: (A) ⇒ B): A
注解：返回序列中第一个不符合条件的元素
例：

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

49. mkString

49.1 mkString

语法：def mkString: String
注解：将所有元素组合成一个字符串
例：

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

49.2 mkString(sep: String)

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

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

49.3 mkString(start: String, sep: String, end: String)

语法：def mkString(start: String, sep: String, end: String): String
注解：将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾
例：

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

50. nonEmpty

语法：def nonEmpty: Boolean
注解：判断序列不是空

51. orElse

语法：def orElse[A1 <: Int, B1 >: Any](that: PartialFunction[A1,B1]): PartialFunction[A1,B1]
注解：

52. padTo

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

val a = Array(1, 2, 3, 4, 5)
val b = a.padTo(7,9)    //需要一个长度为 7  的新序列，空出的填充 9
println(b.mkString(","))    // return  1,2,3,4,5,9,9

53. par

语法：def par: ParArray[T]
注解：返回一个并行实现，产生的并行序列，不能被修改
例：

val a = Array(1, 2, 3, 4, 5)
val b = a.par   // 结果：b: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4, 5)
//  "ParArray" size = 5

54. partition

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

val a = Array(1, 2, 3, 4, 5)
val b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0})
println(b._1.mkString(","))     // return  2,4
println(b._2.mkString(","))     // return  1,3,5

55. patch

语法：def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
注解： [pætʃ];批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列 that
例：

val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
val c = a.patch(1,b,2)
println(c.mkString(","))    // return 1,3,4,6,4,5
/**从 a 的索引1的第二个元素开始，取两个元素，即 2和3 ，这两个元素被替换为 b的内容*/

56. permutations

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

val a = Array(1, 2, 3, 4, 5)
val b = a.permutations.toList   // b 中将有120个结果，知道排列组合公式的，应该不难理解吧
/**如果是combinations*/
val b = a.combinations(5).toList    // b 中只有一个，因为不管怎样排列，都是这5个数字组成，所以只能保留第一个val e = Array(1,2,3)
e.permutations.foreach(x=>println(x,mkString(",")))
/**结果
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1
*/

57. prefixLength

语法：def prefixLength(p: (T) ⇒ Boolean): Int
注解：给定一个条件 p，截止到第一个不满足条件的元素，返回一个前置数列的长度，这个数列中的元素都满足 p
例：

val a = Array(1,2,3,4,1,2,3,4)
val b = a.prefixLength( {x:Int => x<4})	 // b = 3
等同于
val b = a.prefixLength( _ < 4)	

58. product

语法：def product: A
注解：返回所有元素乘积的值(只能是数值型)
例：

val a = Array(1,2,3,4,5)
val b = a.product       // b = 120  （1*2*3*4*5）

59. reduce

59.1 reduce

语法：def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
注解：对序列中的每个元素进行二元运算(一次取2个值)，不需要初始值
例：

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,5)
val b = a.reduce(seqno)
println(b)    	// 结果：15
/**seq_exp=1+2seq_exp=3+3seq_exp=6+4seq_exp=10+5
*/val e = Array(1,2,3)
e.reduce(_+_)		//结果：Int = 6

59.2 reduceLeft

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

59.3 reduceRight

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

59.4 reduceLeftOption

语法：def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
注解：计算Option，参考reduceLeft，防止空数组报错，若空，返回None

59.5 reduceRightOption

语法：def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
注解：计算Option，参考reduceRight，防止空数组报错，若空，返回None

60. repr

语法：def repr: Array[A1]
注解：

61. reverse

61.1 reverse

语法：def reverse: Array[T]
注解：反转序列
例：

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

61.2 reverseIterator

语法：def reverseIterator: collection.Iterator[T]
注解：反向生成迭代

61.3 reverseMap

语法：def reverseMap[B](f: (A) ⇒ B): Array[B]
注解：同 map 方向相反
例：

val a = Array(1,2,3,4,5)
val b = a.reverseMap( {x:Int => x*10} )
println(b.mkString(","))    // 50,40,30,20,10

62. runWith

语法：def runWith[U](action: A1 => U): Int => Boolean
注解：

63. sameElements

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

val a = Array(1,2,3,4,5)
val b = Array(1,2,3,4,5)
println(a.sameElements(b))  // trueval c = Array(1,2,3,5,4)
println(a.sameElements(c))  // false

64. scan

64.1 scan

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

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

64.2 scanLeft

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

64.3 scanRight

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

65. segmentLength

语法：def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
注解：从序列的索引 from 处开始向后查找，所有满足 p 的连续元素的长度
例：

val a = Array(1,2,3,1,1,1,1,1,4,1,5)
val b = a.segmentLength( {x:Int => x < 3},3)        // 5
val b = a.segmentLength( {x:Int => x < 3},4)        // 4

66. seq

语法：def seq: collection.mutable.IndexedSeq[T]
注解：产生一个引用当前序列的 sequential 视图
例：

val e = Array(1,3,2)
e.seq.foreach(println)
/** 结果
1
3
2
*/

67. size

语法：def size: Int
注解：序列元素个数，同 length

68. slice

语法：def slice(from: Int, until: Int): Array[T]
注解： [slaɪs];取出当前序列中，from 到 until 之间的片段(左包右不包)
例：

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

69. sliding

69.1 sliding(size: Int): collection.Iterator[Array[T]]

语法: def sliding(size: Int): collection.Iterator[Array[T]]
注解： [ˈslaɪdɪŋ]；从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
例：

val a = Array(1,2,3,4,5)
val b = a.sliding(3).toList
for(i<-0 to b.length - 1){val s = "第%d个：%s"println(s.format(i,b(i).mkString(",")))
}/**
第0个：1,2,3
第1个：2,3,4
第2个：3,4,5*/

69.2 sliding(size: Int, step: Int): collection.Iterator[Array[T]]

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

val a = Array(1,2,3,4,5)
val b = a.sliding(3,2).toList   //第一个从1开始， 第二个从3开始，因为步进是 2
for(i<-0 to b.length - 1){val s = "第%d个：%s"println(s.format(i,b(i).mkString(",")))
}/**
第0个：1,2,3
第1个：3,4,5*/

70. sortBy sortWith sorted

70.1 sortBy

语法：def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
注解：按指定的排序规则排序
例：

val a = Array(3,2,1,4,5)
val b = a.sortBy( {x:Int => x})
println(b.mkString(","))    // 1,2,3,4,5
// 倒序
val b = a.sortBy( {x:Int => -x})
println(b.mkString(","))    // 5,4,3,2,1

70.2 sortWith

语法：def sortWith(lt: (T, T) ⇒ Boolean): Array[T]
注解：自定义排序方法 lt
例：

val a = Array(3,2,1,4,5)
val b = a.sortWith(_.compareTo(_) > 0)  // 倒序
println(b.mkString(","))    // 5,4,3,2,1
val b = a.sortWith(_.compareTo(_) < 0)  // 正序
println(b.mkString(","))    // 1,2,3,4,5val ff = Array(("张三",50),("李四",70),("王不二",88))
val fd = ff.sortBy(x => x._2)
// fd : Array[(String, Int)] = Array((张三,50), (李四,70), (王不二,88))

70.3 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

71. span

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

val a = Array(3,2,1,4,5)
val b = a.span( {x:Int => x > 2})
println(b._1.mkString(","))     //  3
println(b._2.mkString(","))     //  2,1,4,5

72. splitAt

语法：def splitAt(n: Int): (Array[T], Array[T])
注解：从指定位置开始，把序列拆分成两个集合
例：

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

73. startsWith

语法1：def startsWith[B](that: GenSeq[B], offset: Int): Boolean
注解1：从指定偏移处，是否以某个序列开始
例：

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

语法2：def startsWith[B](that: GenSeq[B]): Boolean
注解2：是否以某个序列开始
例：

val a = Array(1,2,3,4,5)
val b = Array(1,2)
println(a.startsWith(b))        //  true

74. stringPrefix

语法：def stringPrefix: String
注解：返回 toString 结果的前缀
例：

val a = Array(0,1,2,3,4,5)
println(a.toString())       //[I@3daa57fb
val b = a.stringPrefix
println(b)      //[I

75. subSequence

语法：def subSequence(start: Int, end: Int): CharSequence
注解：返回 start 和 end 间的字符序列(数组类型必须是Array[Char])(左包右不包)
例:

val chars = Array('a','b','c','d')
val b = chars.subSequence(1,3)
println(b.toString)     //  bc

76. sum

语法：def sum: A
注解：序列求和，元素需为Numeric[T]类型
例：

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

77. tail tails

77.1 tail

语法：def tail: Array[T]
注解：返回除了当前序列第一个元素的其它元素组成的序列
（与init相反）
例：

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

77.2 tails

语法：def tails: Array[T]
注解：对集合中的元素进行 tail 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行tail操作，上一步的结果作为下一步的操作对象
例：

val a = Array(1, 2, 3, 4, 5)
val b = a.tails.toList
b	//b: List[Array[Int]] = List(Array(1, 2, 3, 4, 5), Array(2, 3, 4, 5), Array(3, 4, 5), Array(4, 5), Array(5), Array())
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个值：2,3,4,5
第3个值：3,4,5
第4个值：4,5
第5个值：5
第6个值：
*/

78. take

78.1 take

语法：def take(n: Int): Array[T]
注解：返回当前序列中前 n 个元素组成的序列
例:

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

78.2 takeRight

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

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

78.3 takeWhile

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

 val a = Array(1,2,3,4,5)val b = a.takeWhile( {x:Int => x < 3})      //  1,2

79. to

79.1 toArray

语法：def toArray: Array[A]
注解：转换成 Array 类型

79.2 toBuffer

语法：def toBuffer[A1 >: A]: Buffer[A1]
注解：转换成 Buffer 类型

79.3 toIndexedSeq

语法：def toIndexedSeq: collection.immutable.IndexedSeq[T]
注解：转换成 IndexedSeq 类型

79.4 toIterable

语法：def toIterable: collection.Iterable[T]
注解: 转换成可迭代的类型

79.5 toIterator

语法：def toIterator: collection.Iterator[T]
注解：同 iterator 方法

79.6 toList

语法：def toList: List[T]
注解：同 List 类型

79.7 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)val a = Array(1,3,4,5,2,5)
val b = a.map((_,1))
val c = b.toMap

79.8 toSeq

语法：def toSeq: collection.Seq[T]
注解：同 Seq 类型

79.9 toSet

语法：def toSet[B >: A]: Set[B]
注解：同 Set 类型

79.10 toStream

语法：def toStream: collection.immutable.Stream[T]
注解：同 Stream 类型(流)

79.11 toVector

语法：def toVector: Vector[T]
注解：同 Vector 类型

79.12 toTraversable

语法：def toTraversable: Traversable[T]
注解：同 Traversable类型

80. transform

语法： def transform(f: T => T): scala.collection.mutable.WrappedArray[T]
注解：

81. transpose

语法：def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
注解：矩阵转换，二维数组行列转换(转置)
例：

val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
val b = chars.transpose
println(b.mkString(","))val k = Array(Array(1,3,2),Array(5,8,2),Array(7,9,8),Array(2,7,5))
val j = k.transpose
// j: Array[Array[Int]] = Array(Array(1, 5, 7, 2), Array(3, 8, 9, 7), Array(2, 2, 8, 5))

转换结果

82. union

语法：def union(that: collection.Seq[T]): Array[T]
注解：联合两个序列，同操作符 ++(不去重)
例；

val a = Array(1,2,3,4,5)
val b = Array(6,7)
val c = a.union(b)
println(c.mkString(","))        // 1,2,3,4,5,6,7val a = Array(1,3,3,2,4,5)
val b = Array(4,2,3,8,7,9)
val c = a.union(b)	//c: Array[Int] = Array(1, 3, 3, 2, 4, 5, 4, 2, 3, 8, 7, 9)

83. unzip unzip3

83.1 unzip

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

val chars = Array(("a","b"),("c","d"))
val b = chars.unzip		//b: (Array[String], Array[String]) = (Array(a, c),Array(b, d))
println(b._1.mkString(","))     //a,c
println(b._2.mkString(","))     //b,d

83.2 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 chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
val b = chars.unzip3
println(b._1.mkString(","))     //a,c,e
println(b._2.mkString(","))     //b,d,f
println(b._3.mkString(","))     //x,y,z

84. update

语法1：def update(i: Int, x: T): Unit
注解：将序列中 i 索引处的元素更新为 x
例：

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

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

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

85. view

语法：def view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
注解：返回 from 到 until 间的序列，不包括 until 处的元素
例：

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

86. withFilter

语法：def withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
注解：根据条件 p 过滤元素(返回特殊类型FilterMonadic[T, Array[T]])
例：

val a = Array(1,2,3,4,5)
val b = a.withFilter( {x:Int => x>3})	
// b: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@3a36da5e
val c = b.map(x=>x)
println(c.mkString(","))        //4,5

87. zip zipAll zipWithIndex

87.1 zip

语法：def zip[B](that: GenIterable[B]): Array[(A, B)]
注解：将两个序列对应位置上的元素组成一个pair序列

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

87.2 zipAll

语法：def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
注解：同 zip ，但是允许两个序列长度不一样，不足的自动填充，如果当前序列端，空出的填充为 thisElem，如果 that 短，填充为 thatElem

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)

87.3 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)