Scala Array方法一览

Scala：Array(集合、序列)

1、++
合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。(不去重)

val a=Array(1,2,3)
val b=Array(4,5,6)
val c= a ++ b

2、++:
合并集合，并返回一个新的数组，右边操纵数的类型决定着返回结果的类型

val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b

注：c的类型是：scala.collection.mutable.LinkedList

3、+:
在数组前面添加一个元素，并返回新的对象

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

4、:+
在数组末尾添加一个元素，并返回新对象

val b = List(3,4)
val c = b :+ 0 // c中的内容是 （3,4,0）

5、/:
对数组中所有的元素进行相同的操作，foldLeft的简写

val a=List(1,2,3,4)
val c=(10 /: a)(_+_)   //10+1+2+3+4  计算方向 ——>
val d=(10 /: a)(_*_)   //10*1*2*3*4  计算方向 ——>

6、 :
对数组中所有的元素进行相同的操作，foldRight的简写

val a=List(1,2,3,4)
val c=(a :\ 10)(_+_)   //1+2+3+4+10  计算方向 <——
val d=(a :\ 10)(_*_)   //1*2*3*4*10  计算方向 <——

7、addString
addString(b:StringBuilder):StringBuilder
将a数组中的元素逐个添加到b中

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

addString(b:StringBuilder,sep:String):StringBuilder
将a数组中的元素逐个添加到b中,并且每个元素用sep分隔符分开

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

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

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

8、aggregate
聚合计算，aggregate是柯里化方法
示例：为了方便理解，把 aggregate 的两个参数分别封装成两个方法，并把分区和不分区的计算过程分别打印出来

def seqno(m: Int, n: Int): Int = {
val s = “seq_exp = %d + %d”
println(s.format(m, n))
m + n
}

def combine(m: Int, n: Int): Int = {
val s = “com_exp = %d + %d”
println(s.format(m, n))
m + n
}

def main(args: Array[String]) {
val a = List(1, 2, 3, 4)

val b = a.aggregate(5)(seqno, combine) // 不分区
println("b = " + b)
/**
 * seq_exp = 5 + 1
 * seq_exp = 6 + 2
 * seq_exp = 8 + 3
 * seq_exp = 11 + 4
 * b = 15
 */

val c = a.par.aggregate(5)(seqno, combine) // 分区
println("c = " + c)
/**
 * 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
 */
}

通过上面的运算不难发现，不分区时，seqno 是把初始值顺序和每个元素相加，把得到的结果与下一个元素进行运算。

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

上面过程可以简写为

val b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区

9、apply(i:int)
取出指定索引处的元素

val a=List(1,2,3,4)
val first=a.apply(0)   //读取第一个元素
等同于：val first=arr(0)  //读取第一个元素

10、canEqual
判断两个对象是否可以进行比较

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

val chars = Array('a','b','c')
val c=chars.charAt(0)   //c的结果为 a

12、clone()
创建一个副本

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

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

val chars = Array('a','b','c')
//通过下面的偏函数，把chars数组的小写a、b转换为大写的A、B
val fun:PartialFunction[Char, Char]={
    case 'a' => 'A'
    case 'b' => 'B'
    case x => x
}
chars.collect(fun)     // 输出结果：Array(A, B, c)

14、collectFirst
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

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

//另一种写法
val value = arr.collectFirst({case x:Int => x*100})

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

val arr = Array("a","b","c")
val newarr = arr.combinations(2)
newarr.foreach((item) => println(item.mkString(",")))
/**
a,b
a,c
b,c
*/

16、contains
序列中是否包含指定对象，包含则输出true,不包含则输出false

val arr = Array("a","b","c","d","e","f")
arr.contains("a")  // true
arr.contains("s")  // false

17、containsSlice
判断当前序列中是否包含另一个序列，如果另一个序列中的元素连续且相同于当前序列，则返回true，反之则返回false

val a = List(1,2,3,4)
val b = List(1,2)
a.containsSlice(b)  //true

val c = List(2,1)
a.containsSlice(c)  //false

val d = List(1,4)
a.containsSlice(d)  //false

18、copyToArray
此方法还有两个类似的方法：

copyToArray(xs: Array[A], start: Int): Unit
copyToArray(xs: Array[A], start: Int, len: Int): Unit
val a = Array('a','b','c')
val b:Array[Char] = new Array(5)   //定义一个长度为5的char类型数组b
a.copyToArray(b)   //复制数组a中元素至数组b
b  //查看b中元素  Array[Char] = Array(a, b, c, ?, ?)

val b:Array[Char] = new Array(5)
a.copyToArray(b,2)   //从数组b索引为2的位置开始，复制数组a中元素至数组b
b   //查看b中元素  Array[Char] = Array(?, ?, a, b, c)

val b:Array[Char] = new Array(5)
a.copyToArray(b,2,2)   //从数组b索引为2的位置开始，复制数组a中元素至数组b，复制的元素个数为2
b   //查看b中元素  Array[Char] = Array(?, ?, a, b, ?)

19、copyToBuffer
将数组中的内容拷贝到Buffer中
//前提：导入可变集合

import scala.collection.mutable._

val a = Array('a','b','c')
val b:ArrayBuffer[Char] = ArrayBuffer()   //定义Buffer类型数组b
a.copyToBuffer(b)   //复制数组a中元素至数组b
b   //查看数组b： ArrayBuffer(a, b, c)
b.toString   //输出数组b： String = ArrayBuffer(a, b, c)

b.append('d')   //为数组b添加元素'd'
b   //查看数组b：ArrayBuffer(a, b, c, d)
b.append('e')   //为数组b添加元素'e'
b   //查看数组b：ArrayBuffer(a, b, c, d, e)

//将数组b按自定义样式输出

b.mkString("{","^","}")   // 输出结果：{a^b^c^d^e}

20、correspond
判断两个序列长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且p(x, y)=true，返回结果为true

val a = Array(1,2,3)
val b = Array(3,4,5)
//检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素
a.corresponds(b)(_<_)    //true

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

val b = Array(4,5,6,7)
a.corresponds(b)(_<_)   // false

val b = Array(4,5)
a.corresponds(b)(_<_)   // false

21、count

统计符合条件的元素个数
val a = Array(1,2,3)
//统计大于2的元素个数
a.count(x => x>2)   //1
//统计大于0的元素个数
a.count(x => x>0)   //3
//统计大于1的元素个数
a.count(x => x>1)   //2

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

val a = Array(1,2,3,4)
val b = Array(4,5,6)
//计算数组a中没有在数组b中出现的元素
a.diff(b)   //结果：Array(1, 2, 3)
//计算数组b中没有在数组a中出现的元素
b.diff(a)   //结果：Array(5, 6)

23、distinct
去除当前集合中重复的元素，只保留一个

val a = Array(1,1,2,2,3,3,5,5,6,7,7)
//去除数组a中重复的元素
val c = a.distinct   //结果：Array(1, 2, 3, 5, 6, 7)

24、drop(n: Int)

将当前序列中前 n 个元素去除后，作为一个新序列返回
val a = Array(1,2,3,4)
//去除当前序列的前2个元素
a.drop(2)   //结果：Array(3, 4)

25、dropRight(n: Int)
功能同 drop，去掉尾部的 n 个元素

val a = Array(1,2,3,4)
//去除当前序列的前2个元素
a.dropRight(2)   //结果：Array(1, 2)

26、dropWhile
去除当前数组中符合条件的元素，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组
//下面去除大于2的元素直至条件不满足，第一个元素3满足,第二个元素2不满足

val a = Array(3,2,3,4)
val c = a.dropWhile({x:Int => x>2})   //Array(2, 3, 4)

//简写
val c = a.dropWhile(_>2)   //Array(2, 3, 4)

27、endsWith
判断是否以某个序列结尾，元素连续且顺序相同

val a = Array(3,2,3,4)
val b = Array(3,4)
//判断序列a是否以序列b结尾
a.endsWith(b)    // true
//判断序列a是否以序列c结尾
val c = Array(2,3)
a.endsWith(c)    // false

28、exists
判断当前数组是否包含符合条件的元素

val a = Array(3,2,3,4)
//判断数组a是否包含元素3
a.exists(_==3)     // true

//另一种写法:
a.exists(x=>x==3)  // true

//判断数组a是否包含元素1
a.exists(x=> x==1) // false

/找到符合条件的第一个元素就停止（即使后面还有符合条件的元素），存在则返回true，不存在则返回false
//输出序列a元素，直至出现大于1的元素为止
a.exists(x=> {println(x);x>1})
/**
3
Boolean = true
*/

//输出序列a元素，直至出现大于3的元素为止
a.exists(x=> {println(x);x>3})

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

val a = Array(3,2,3,4)
//取得数组a中大于2的元素
val b = a.filter(x=>x>2)   //结果：Array(3, 3, 4)
//取得数组a中大于3的元素
val b = a.filter(x=>x>3)   //结果： Array(4)

30、filterNot
与上面的 filter 作用相反，取得当前数组中不符合条件的元素，组成新的数组返回

val a = Array(3,2,3,4)
//取得数组a中不符合大于4条件的元素(相当于输出数组a中小于等于4的元素)
val b = a.filterNot(x=>x>4)  //结果：Array(3, 2, 3, 4)
//取得数组a中不符合大于2条件的元素(相当于输出数组a中小于等于2的元素)
val b = a.filterNot(x=>x>2)  //结果： Array(2)

31、find
查找第一个符合条件的元素，存在则输出元素，反之则输出None

val a = Array(3,2,3,4)
//查找大于3的第一个元素
val b = a.find(x => x>3)  //结果：Option[Int] = Some(4)
//查找大于2的第一个元素
scala> val b = a.find(x => x>2)  //结果：Option[Int] = Some(3)
//查找大于5的第一个元素
scala> val b = a.find(x => x>5)  //结果： Option[Int] = None

32、flatMap
对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类

val a = Array(3,2,3,4)
//集合a的每个元素，分别从1开始，递增至该元素
a.flatMap(1 to _)  // 1,2,3,1,2,1,2,3,1,2,3,4

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

//定义一个Int类型的二维数组
val darr = Array(Array(1,2,3),Array(4,5,6))
//联合二维数组的所有元素
darr.flatten  //结果：Array[Int] = Array(1, 2, 3, 4, 5, 6)

//定义一个String类型的二维数组
val darr = Array(Array("hello","java","scala"),Array("world","gree","kb09"))
darr.flatten   //结果：Array[String] = Array(hello, java, scala, world, gree, kb09)

34、fold
对序列中的每个元素进行二元运算，和aggregate有类似的语义，但执行过程有所不同

35、foldLeft

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

def seqno(x:Int, y:Int):Int={
    println("seqno",x,y)
    x+y
}
val a = Array(1,2,3,4)
a.foldLeft(5)(seqno)

/**
(seqno,5,1)
(seqno,6,2)
(seqno,8,3)
(seqno,11,4)
res135: Int = 15
*/

//简写代码
(5 /: a)(_+_)   // 15

36、foldRight

从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B
def seqno(x:Int, y:Int):Int={
    println("seqno",x,y)
    x+y
}
val a = Array(1,2,3,4)
a.foldRight(5)(seqno)

/**
(seqno,4,5)
(seqno,3,9)
(seqno,2,12)
(seqno,1,14)
res137: Int = 15
*/

//简写代码
(a :\ 5)(_+_)   // 15

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

val a = Array(1,2,3,4)
//判断序列a中的元素是否都大于1
a.forAll(_>1)  // false
//判断序列a中的元素是否都大于0
a.forAll(_>0)  // true

38、foreachp: (T) ⇒ Boolean): Boolean
遍历检测序列中的元素是否都满足条件 p，如果序列为空，返回true

val a = Array(1,2,3,4)
//遍历序列a元素，分别判断该元素是否大于2
a.foreach(x => println(x>2)) 
/**
false
false
true
true
*/

39、foreach(f: (A) ⇒ Unit): Unit
遍历序列中的元素，进行 f 操作

val a = Array(1,2,3,4)
//遍历序列a元素，分别输出该元素*10的结果
a.foreach(x => println(x*10))
/**
10
20
30
40
*/

40、groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列

val a = Array(1,2,3,4)
//将序列a中的每个元素按其值分组
val b = a.groupBy(x => x)  //结果：Map(2 -> Array(2), 4 -> Array(4), 1 -> Array(1), 3 -> Array(3))

//把小于3的数字放到一组，大于3的放到一组，等于3的放到一组，返回Map[String,Array[Int]]
val b = a.groupBy(x => x match{
    case x if(x<3) => "small"
    case x if(x==3) => "equal"
    case _ => "big"
})

//结果：Map(small -> Array(1, 2), big -> Array(4), equal -> Array(3))

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

val a = Array(1,2,3,4)
//将序列a按每组2个元素进行分组
a.grouped(2).toList  //结果：List(Array(1, 2), Array(3, 4))

//将序列a按每组2个元素进行分组，不足指定数量的也分出一组
val a = Array(1,2,3,4,5)
a.grouped(2).toList  //结果：List(Array(1, 2), Array(3, 4), Array(5))

42、hasDefiniteSize
检测序列是否存在有限的长度，对应Stream这样的流数据，返回false

val a = Array(1,2,3,4,5)
//检测序列a是否存在有限长度
a.hasDefiniteSize  // true

43、head

返回序列的第一个元素，如果序列为空，将引发错误

val a = Array(1,2,3,4,5)
//获取序列a的第一个元素
a.head  // 1

//等同于
a.apply(0)
val first=a(0)

44、headOption
返回Option类型对象，就是scala.Some 或者 None，如果序列是空，返回None

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

val b:Array[Int] = Array()
b.headOption     // None

45、indexOf(elem: T)
返回elem在序列中的索引，找到第一个就返回其所在位置

val a = Array(1,2,3,4,5)
//返回元素2在序列a中的索引
a.indexOf(2)   // 1
//返回元素4在序列a中的索引
a.indexOf(4)   // 3

46、indexOf(elem: T, from: Int)
返回elem在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回
如果要查找的不存在或者存在但没找到，则返回-1；找到则返回第一个的索引

val arr = Array("hello scala","hello python","hello spark","happy study","happy love")
//从索引为2的位置开始查找"hello scala"
arr.indexOf("hello scala",2)        // -1
//从索引为3的位置开始查找"hello love"
arr.indexOf("hello love",3)         // -1
//从索引为2的位置开始查找"happy love"
arr.indexOf("happy love",2)         // 4

47、indexOfSlice
检测当前序列中是否包含另一个序列，并返回第一个匹配出现的元素的索引；如果不包含则返回-1

val a = Array(1,2,3,4,5,6)
val d = Array(3,4,5)
a.indexOfSlice(d)   // Int = 2

val d = Array(3,5,4)
a.indexOfSlice(d)   // Int = -1

48、indexOfSlice[B >: A](that: GenSeq[B], from: Int)
检测当前序列中是否包含另一个序列（that），并返回第一个匹配出现的元素的索引，指定从 from 索引处开始
子序列要求：连续且相同
如果包含则返回匹配到的第一个元素的索引；匹配不到则返回-1

val a = Array(1,2,3,4,5,6)
val b = Array(3,4,5)        // Array(3, 4, 5)
a.indexOfSlice(b,1)         // Int = 2

val b = Array(3,5)
a.indexOfSlice(b,1)         // Int = -1

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

val a = Array(1,2,3,4,5,6)
a.indexWhere(x => x==3)       // Int = 2
a.indexWhere(x => x>3)        // Int = 3

50、indexWhere(p: (T) ⇒ Boolean, from: Int)
返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始

val a = Array(1,2,3,4,5,6)
a.indexWhere(x => x>3, 5)   // Int = 5
a.indexWhere(x => x>3, 4)   // Int = 4

51、indices
返回当前序列的索引集合

val a = Array(1,2,3,4,5,6)
a.indices     // 结果：scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5)

52、init
返回当前序列中不包含最后一个元素的序列

val a = Array(1,2,3,4,5,6)
a.init     // Array(1, 2, 3, 4, 5)

53、inits
对集合中的元素进行 init 操作，该操作的返回值中， 第一个值是当前序列的副本，包含当前序列所有的元素，最后一个值是空的，对头尾之间的值进行init操作，上一步的结果作为下一步的操作对象

val a = Array(1,2,3,4,5,6)
a.inits.toList
// 结果：List(Array(1, 2, 3, 4, 5, 6), Array(1, 2, 3, 4, 5), Array(1, 2, 3, 4), Array(1, 2, 3), Array(1, 2), Array(1), Array())

54、intersect
取两个集合的交集

val a = Array(1,2,3,4,5)
val b = Array(2,4,6)
//取a、b两个集合的交集
a.intersect(b)       // Array(2, 4)

55、isDefinedAt(idx: Int)
判断序列中是否存在指定索引，存在则返回true，反之则返回false

val a = Array(1,2,3,4,5,6)
//判断序列a中是否存在索引3
a.isDefinedAt(3)          // Boolean = true
//判断序列a中是否存在索引10
a.isDefinedAt(10)         // Boolean = false

56、isEmpty
判断当前序列是否为空，为空则返回true，不为空则返回false

val a = Array(1,2,3,4,5,6)
a.isEmpty     // Boolean = false

val c:Array[Int] = Array()
c.isEmpty     // Boolean = true

57、isTraversableAgain
判断序列是否可以反复遍历，该方法是GenTraversableOnce中的方法，对于 Traversables 一般返回true，对于 Iterators 返回 false，除非被复写

58、iterator
对序列中的每个元素产生一个 iterator

val a = Array(1,2,3,4,5,6)
a.iterator.toList     // List(1, 2, 3, 4, 5, 6)
a.iterator.toArray    // Array(1, 2, 3, 4, 5, 6)

59、last
取得序列中最后一个元素

val a = Array(1,2,3,4,5,6)
a.last    // Int = 6

60、lastIndexOf(elem: T)
取得序列中最后一个等于 elem 的元素的位置

val a = Array(1,2,3,1,2,3,1,2)
a.lastIndexOf(2)     // Int = 7
a.lastIndexOf(3)     // Int = 5

61、lastIndexOf(elem: T, end: Int)
取得序列中最后一个等于 elem 的元素的位置，可以指定在 end 之前（包括）的元素中查找
如果存在则返回对应的索引，不存在则返回-1

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

62、lastIndexOfSlice
判断当前序列中是否包含序列，并返回最后一次出现该序列的位置处的索引，如果不包含则返回-1

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

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

scala> val a = Array(1,4,2,3,4,5,1,4)
val b = Array(1,4)
a.lastIndexOfSlice(b,4)    // Int = 0

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

val a = Array(1,4,2,3,4,5,1,4)
a.lastIndexWhere(_<2)    // Int = 6
a.lastIndexWhere(_>3)    // Int = 7

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

val a = Array(1,4,2,3,4,5,1,4)
a.lastIndexWhere(_>3,6)      // Int = 5
a.lastIndexWhere(_<2,5)      // Int = 0

66、lastOption
返回当前序列中最后一个对象

val a = Array(1,2,3,4,5)
a.lastOption    // Option[Int] = Some(5)

67、length
返回当前序列中元素个数

val a = Array(1,2,3,4,5)
a.length     // Int = 5
//等同于：a.size

68、lengthCompare(len: Int)
比较序列的长度和参数 len，根据二者的关系返回不同的值
比较规则如下：
返回负数：len > 序列长度 （返回值为 len-序列长度）
返回正数：len < 序列长度
返回0：len = 序列长度

val a = Array(1,2,3,4,5,6)
a.lengthCompare(7)    // Int = -1
a.lengthCompare(5)    // Int = 1
a.lengthCompare(6)    // Int = 0
a.lengthCompare(9)    // Int = -3

69、map[B](f: (A) ⇒ B)
对序列中的元素进行 f 操作

val a = Array(1,2,3,4,5,6)
a.map({x:Int => x+10})      // Array(11, 12, 13, 14, 15, 16)

70、max
返回序列中最大的元素

val a = Array(1,2,3,4,5,6)
a.max     // Int = 6

71、maxBy
返回序列中第一个符合条件的最大的元素，如果没有符合条件的则输出整个序列的第一个元素

val a = Array(1,2,3,4,5,6)
a.maxBy(_>2)     // Int = 3
a.maxBy(_>7)     // Int = 1

72、mkString
mkString: String
将所有元素组合成一个字符串

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

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

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

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

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

73、nonEmpty
判断序列不是空，如果不为空则返回true，为空则返回false

val a = Array(1,2,3,4,5)
a.nonEmpty     // Boolean = true
val c:Array[Int] = Array()
c.nonEmpty     // Boolean = false

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

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

a.padTo(5,9)   // 结果：Array(1, 2, 3, 4, 5)
a.padTo(4,9)   // 结果：Array(1, 2, 3, 4, 5)

75、par
返回一个并行实现，产生的并行序列，不能被修改

val a = Array(1,2,3,4,5)
a.par     // 结果：ParArray(1, 2, 3, 4, 5)

76、partition
按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列

val a = Array(3,2,1)
a.partition(x => x%2==0)    // (Array(2),Array(3, 1))

a.partition(x => x%3==1)    // (Array(1),Array(3, 2))

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

val a = Array(1,2,3,4,5,6,7,8)
val b = Array(11,12,13)
a.patch(3,b,1)       // Array(1, 2, 3, 11, 12, 13, 5, 6, 7, 8)

a.patch(3,b,2)       // Array(1, 2, 3, 11, 12, 13, 6, 7, 8)

a.patch(3,b,5)       // Array(1, 2, 3, 11, 12, 13)

78、permutations
排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同，combinations不允许包含的内容相同，即使顺序不一样

val a = Array(1,2,3)
a.permutations.toList
// 结果：List(Array(1, 2, 3), Array(1, 3, 2), Array(2, 1, 3), Array(2, 3, 1), Array(3, 1, 2), Array(3, 2, 1))

//对比combinations方法
val a = Array(1,2,3)
a.combinations(2).toList     // List(Array(1, 2), Array(1, 3), Array(2, 3))
a.combinations(3).toList     // List(Array(1, 2, 3))

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

scala> val a = Array(1,2,3,4,5)
a.prefixLength(_>2)     // Int = 0
a.prefixLength(_<3)     // Int = 2

80、product
返回所有元素乘积的值

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

81、reduce
同 fold，不需要初始值

val a = Array(1,2,3,4,5)
a.reduce((x,y) => {println(x,y);x+y})
/**
(1,2)
(3,3)
(6,4)
(10,5)
Int = 15
*/

//对比fold方法
a.fold(5)((x,y) => {println(x,y);x+y})
/**
(5,1)
(6,2)
(8,3)
(11,4)
(15,5)
Int = 20
*/

82、reduceLeft
从左向右计算

val a = Array(1,2,3,4,5)
a.reduceLeft((x,y) => {println(x,y);x+y})
/**
(1,2)
(3,3)
(6,4)
(10,5)
Int = 15
*/

83、reduceRight
从右向左计算

val a = Array(1,2,3,4,5)
a.reduceRight((x,y) => {println(x,y);x+y})
/**
(4,5)
(3,9)
(2,12)
(1,14)
Int = 15
*/

84、reduceLeftOption
计算Option，参考reduceLeft

val a = Array(1,2,3,4,5)
a.reduceLeftOption((x,y) => {println(x,y);x+y})
/**
(1,2)
(3,3)
(6,4)
(10,5)
Option[Int] = Some(15)
*/

85、reduceRightOption
计算Option，参考reduceRight

val a = Array(1,2,3,4,5)
a.reduceRightOption((x,y) => {println(x,y);x+y})
/**
(4,5)
(3,9)
(2,12)
(1,14)
Option[Int] = Some(15)
*/

86、reverse
反转序列

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

87、reverseIterator
反向生成迭代

val a = Array(1,2,3,4,5)
a.reverseIterator.toList      // List(5, 4, 3, 2, 1)

88、reverseMap[B](f: (A) ⇒ B)
同 map，对序列中的元素进行 f 操作，但方向相反

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

89、sameElements
判断两个序列是否顺序和对应位置上的元素都一样，相同则返回true，不同则返回false

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

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

90、scan
用法同 fold，scan会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是单一的值

val a = Array(1,2,3,4,5)
def seqno(x:Int,y:Int):Int={
    println("seqno",x,y)
    x+y
}
seqno: (x: Int, y: Int)Int
a.scan(5)(seqno)
/**
(seqno,5,1)
(seqno,6,2)
(seqno,8,3)
(seqno,11,4)
(seqno,15,5)
Array[Int] = Array(5, 6, 8, 11, 15, 20)
*/

91、scanLeft
从左向右计算

val a = Array(1,2,3,4,5)
a.scanLeft(5)(seqno)
/**
(seqno,5,1)
(seqno,6,2)
(seqno,8,3)
(seqno,11,4)
(seqno,15,5)
Array[Int] = Array(5, 6, 8, 11, 15, 20)
*/

92、scanRight
从右向左计算

scala> val a = Array(1,2,3,4,5)
a.scanRight(5)(seqno)
/**
(seqno,5,5)
(seqno,4,10)
(seqno,3,14)
(seqno,2,17)
(seqno,1,19)
Array[Int] = Array(20, 19, 17, 14, 10, 5)
*/

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

val a = Array(1,2,3,1,1,1,4,5)
a.segmentLength(_<3,3)     // Int = 3

94、seq
产生一个引用当前序列的 sequential 视图

val a = Array(1,2,3,4,5)
a.seq      // 结果：WrappedArray(1, 2, 3, 4, 5)

95、size
序列元素个数，同 length

val a = Array(1,2,3,4,5)
a.size    // Int = 5
//等同于：a.length 

96、slice(from:Int, until:Int)
取出当前序列中，索引为 from 到 until 之间的元素（左闭右开）

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

97、sliding
sliding(size:Int)
从第一个元素开始，每个元素和它后面的 (size - 1) 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止

val a = Array(1,2,3,4,5)
a.sliding(2).toList    // List(Array(1, 2), Array(2, 3), Array(3, 4), Array(4, 5))
a.sliding(3).toList    // List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5))
a.sliding(4).toList    // List(Array(1, 2, 3, 4), Array(2, 3, 4, 5))
a.sliding(5).toList    // List(Array(1, 2, 3, 4, 5))

sliding(size:Int, step:Int)
从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止
该方法，可以设置步进 step，第一个元素组合完后，下一个从 (上一个元素位置+step)后的位置处的元素开始(滑动获取元素)

val a = Array(1,2,3,4,5,6,7,8,9,10,11,12,13)
//3个元素一集合，滑动位移为1
a.sliding(3,1).toList  
// 结果：List(Array(1, 2, 3), Array(2, 3, 4), Array(3, 4, 5), Array(4, 5, 6), Array(5, 6, 7), Array(6, 7, 8), Array(7, 8, 9), Array(8, 9, 10), Array(9, 10, 11), Array(10, 11, 12), Array(11, 12, 13))

//3个元素一集合，滑动位移为1
a.sliding(3,3).toList
// 结果：List(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9), Array(10, 11, 12), Array(13))

98、sortBy
按指定的排序规则排序，默认升序排序

val a = Array(1,2,3,4,5,6,7,8,9,10,11,12,13)
//降序排列
a.sortBy(x => {-1 * x})     // Array(13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

//定义元组
val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
arr.sorted    // Array((hello,4), (java,6), (scala,3), (world,1))

//自定义排序规则
//按元组的第二个元素升序排序
arr.sortBy(x=>x._2)          // Array((world,1), (scala,3), (hello,4), (java,6))

//按元组的第二个元素降序排序
arr.sortBy(x=>{-1 * x._2})   // Array((java,6), (hello,4), (scala,3), (world,1))

99、sortWith
自定义排序规则

val a = Array(3,2,6,5,8,9,4)
//降序排列（大数在前）
a.sortWith(_.compareTo(_)>0)    // Array(9, 8, 6, 5, 4, 3, 2)

a.sortWith((x,y)=>{println(x,y);x.compareTo(y)>0})
/**
(2,3)
(3,2)
(6,2)
(6,2)
(6,3)
(5,3)
(5,6)
(6,5)
(8,3)
(8,5)
(8,6)
(9,5)
(9,6)
(9,8)
(4,5)
(5,4)
(4,2)
(4,3)
res19: Array[Int] = Array(9, 8, 6, 5, 4, 3, 2)
*/

val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
//按元组第二个元素降序排列
arr.sortWith((x,y) => x._2>y._2)    // Array((java,6), (hello,4), (scala,3), (world,1))

//按元组第二个元素升序排列
arr.sortWith((x,y) => x._2<y._2)    // Array((world,1), (scala,3), (hello,4), (java,6))

100、sorted
使用默认的排序规则（升序）对序列排序

val a = Array(3,2,6,5,8,9,4)
a.sorted    // Array(2, 3, 4, 5, 6, 8, 9)

101、span
分割序列为两个集合
从第一个元素开始，直到找到第一个不满足条件的元素停止，之前的元素放到第一个集合，剩余的放到第二个集合

val a = Array(9,7,4,2,1,8)
a.span(x => x>4)     // (Array[Int], Array[Int]) = (Array(9, 7),Array(4, 2, 1, 8))

102、splitAt(n:Int)
从指定位置开始，把序列拆分成两个集合

val a = Array(9,7,4,2,1,8)
a.splitAt(3)      // (Array[Int], Array[Int]) = (Array(9, 7, 4),Array(2, 1, 8))

a.splitAt(1)      // (Array[Int], Array[Int]) = (Array(9),Array(7, 4, 2, 1, 8))

val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
arr.splitAt(2)    
// (Array[(String, Int)], Array[(String, Int)]) = (Array((hello,4), (world,1)),Array((scala,3), (java,6)))

103、startsWith
startsWith[B](that: GenSeq[B]): Boolean
是否以某个序列开始

val a = Array(1,2,3,4,5,6,7,8)
val b = Array(4,5,6,7)
a.startsWith(b)        // Boolean = false

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

val a = Array(1,2,3,4,5,6,7,8)
val b = Array(4,5,6,7)
//数组a从索引为的3的位置开始，是否以数组b开始
a.startsWith(b,3)     // Boolean = true

a.startsWith(b,0)     // Boolean = false

val c = Array(4,5,6,7,1)
a.startsWith(c,3)     // Boolean = false

104、staringPrefix
返回 toString 结果的前缀
//定义数组类型

val a = Array(1,2,3,4,5,6,7,8)
a.stringPrefix      // String = [I

//定义集合类型
val l = List(1,2,3)
l.stringPrefix      // String = List

//定义元组类型
val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
arr.stringPrefix    // String = Tuple2;

105、subSequence(start:Int, end:Int)
返回索引在 start 和 end 间的字符序列（左闭右开）

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

106、sum
序列求和，元素需为Numeric[T]类型

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

107、tail
返回除了当前序列第一个元素的其它元素组成的序列（去除序列第一个元素）

val a = Array(1,2,3,4,5,6,7,8)
a.tail       // Array(2, 3, 4, 5, 6, 7, 8)

val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
arr.tail     // Array((world,1), (scala,3), (java,6))

108、take(n:Int)
返回当前序列中前 n 个元素组成的序列

val a = Array(1,2,3,4,5,6,7,8)
a.take(2)     // Array(1, 2)
a.take(3)     // Array(1, 2, 3)

109、takeRight(n: Int)
返回当前序列中，从右边开始，选择 n 个元素组成的序列

val a = Array(1,2,3,4,5,6,7,8)
a.takeRight(2)      // Array(7, 8)
a.takeRight(3)      // Array(6, 7, 8)

110、takeWhile
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列

val a = Array(1,2,3,4,5,6,7,8)
a.takeWhile(x=>x>3)    // Array[Int] = Array()

a.takeWhile(x=>x<3)    // Array[Int] = Array(1, 2)

111、toArray
转换成 Array 类型

val a = List(1,2,3,4)
a.toArray     // Array(1, 2, 3, 4)

112、toBuffer
转换成 Buffer 类型

val a = Array(1,2,3,4)
a.toBuffer      // scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4)

113、toIndexedSeq
转换成 IndexedSeq 类型

val a = Array(1,2,3,4)
a.toIndexedSeq     // scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4)

114、toIterable
转换成可迭代的类型

scala> val a = Array(1,2,3,4)
a.toIterable       // Iterable[Int] = WrappedArray(1, 2, 3, 4)

115、toIterator
同 iterator 方法

val a = Array(1,2,3,4)
a.toIterator    // Iterator[Int] = non-empty iterator

116、toList
同 List 类型

val a = Array(1,2,3,4)
a.toList    // List[Int] = List(1, 2, 3, 4)

117、toMap
同 Map 类型，需要被转化序列中包含的元素是 元组类型数据

val arr = Array(("hello",4),("world",1),("scala",3),("java",6))
arr.toMap   // scala.collection.immutable.Map[String,Int] = Map(hello -> 4, world -> 1, scala -> 3, java -> 6)

118、toSeq
同 Seq 类型

val a = Array(1,2,3,4)
a.toSeq    // Seq[Int] = WrappedArray(1, 2, 3, 4)

119、toSet
同 Set 类型

val a = Array(1,2,3,4)
a.toSet     // scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

120、toStream
同 Stream 类型

val a = Array(1,2,3,4)
a.toStream    // scala.collection.immutable.Stream[Int] = Stream(1, ?)

121、toVector
同 Vector 类型

val a = Array(1,2,3,4)
a.toVector     // Vector[Int] = Vector(1, 2, 3, 4)

122、transpose
矩阵转换，二维数组行列转换

val arr = Array(Array("a","b"),Array("c","d"),Array("e","f"),Array("g","h"))
arr.transpose     // Array(Array(a, c, e, g), Array(b, d, f, h))

123、transform
结构转换

val chars3 = Array(("a","b","c"),("d","e","f"),("g","h","i"))
chars3.transform(x=>(x._1+"1",x._2+"2",x._3+"3"))   // WrappedArray((a1,b2,c3), (d1,e2,f3), (g1,h2,i3))

124、unoin
联合两个序列，同操作符 ++

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

125、unzip
将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列

val chars = Array(("a","b"),("c","d"),("e","f"),("g","h"))
chars.unzip    // (Array(a, c, e, g),Array(b, d, f, h))

126、unzip3
将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列

val chars3 = Array(("a","b","c"),("d","e","f"),("g","h","i"))
chars3.unzip3    // (Array(a, d, g),Array(b, e, h),Array(c, f, i))

127、update(i: Int, x: T)
将序列中 i 索引处的元素更新为 x，在原数组上改变

val a = Array(1,2,3,4,5,6,7,8)
a.update(5,100)
a     // Array(1, 2, 3, 4, 5, 100, 7, 8)

128、updated(index: Int, elem: A)
将序列中 i 索引处的元素更新为 x ,并返回替换后的数组，原数组没变，生成新数组

val a = Array(1,2,3,4,5,6,7,8)
a.updated(5,100)     // Array(1, 2, 3, 4, 5, 100, 7, 8)

129、view(from: Int, until: Int)
返回索引在from 到 until 间的元素，不包括 until 处的元素（左闭右开）

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

130、withFilter
根据条件 p 过滤元素，与filter作用相同

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

//等同于：a.filter(x=>x>3)    // Array[Int] = Array(4, 5)

131、zip
将两个序列对应位置上的元素组成一个pair序列

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

val arr = Array(Array("a","b"), Array("c","d"), Array("e","f"), Array("g","h"))
arr.zip(b)   // Array((Array(a, b),6), (Array(c, d),7), (Array(e, f),8), (Array(g, h),9))

132、zipAll
同 zip ，但是允许两个序列长度不一样，不足的自动填充
如果当前序列短，空出的填充为 thisElem，如果 that 短，填充为 thatElem

val b= Array(6,7,8,9,10)
val arr = Array(Array("a","b"), Array("c","d"), Array("e","f"), Array("g","h"))
//以arr为主联合b，arr长度不足则填充4，b长度不足则填充5
arr.zipAll(b,4,5)    // Array((Array(a, b),6), (Array(c, d),7), (Array(e, f),8), (Array(g, h),9), (4,10))

//以b为主联合arr，b长度不足则填充4，arr长度不足则填充5
b.zipAll(arr,4,5)    // Array((6,Array(a, b)), (7,Array(c, d)), (8,Array(e, f)), (9,Array(g, h)), (10,5)) 

133、zipWithIndex
序列中的每个元素和它的索引组成一个序列

val arr1 = Array("dsj1","dsj2","dsj3","dsj4")
arr1.zipWithIndex        // Array((dsj1,0), (dsj2,1), (dsj3,2), (dsj4,3))

arr1.zipWithIndex.map(x=>(x._2,x._1))   // Array((0,dsj1), (1,dsj2), (2,dsj3), (3,dsj4))