scala中常用Array函数

所有函数测试均s以cala交互式编程方式（wimdows cmd 下执行scala）完成。

scala数组

·存储的大小固元素索引
·数组索引从0开始

//数组创建方式一
var a1:Array[String] = new Array[String](3)
a1(0)="Jason"
a1(1)="Marie"
a1(2)="Jimmy"
a1存储结果 Array(Jason, Marie, Jimmy)
//数组创建方式二
var a2=Array("Jason","Marie","Jimmy")
a2存储结果 Array(Jason, Marie, Jimmy)
//数据创建方式三：区间数组 Array(str,end,step) 	 值str区间起始值 end区间终 step取值步长
var a3=Array.range(1,10,2)
a3存储结果 Array(1, 3, 5, 7, 9)

Array常用函数

测试所用变量

var a =Array("zhang","wang","li","123",123)
var b =Array(12,45,78,96,3)
val b1 = Array(1,2,3,4)
var a1 = new StringBuilder()
val c = List(1,2)
val d = scala.collection.mutable.LinkedList(3,4)

1. ++ 或者 union
   合并集合，并返回一个新的集合，新集合包含左右两个集合对象的内容，返回类型和第一个集合类型相同

scala> a++b
res109: Array[Any] = Array(zhang, wang, li, 123, 12, 45, 78, 96, 3)
scala> a.union(c)
res4: Array[Any] = Array(zhang, wang, li, 123, 123, 1, 2)
scala> c ++ a
res7: List[Any] = List(1, 2, zhang, wang, li, 123, 123)

2. ++:
   合并集合，并返回一个新的集合，新集合包含左右两个集合对象的内容,返回类型和右边的相同

scala> c ++: a
res8: Array[Any] = Array(1, 2, zhang, wang, li, 123, 123)
scala> a++:c
res9: List[Any] = List(zhang, wang, li, 123, 123, 1, 2)

3. diff
   集合差集，返回第一个集合中在第二个集合中没有的元素的集合，返回类型和当前集合一样

scala> b.diff(d)
res15: Array[Int] = Array(12, 45, 78, 96)
scala> d.diff(b)
res16: scala.collection.mutable.LinkedList[Int] = LinkedList(4)

4. intersect
   集合交集，返回两个集合公共的元素集合，返回类型和当前集合一样

scala> b.intersect(d)
res18: Array[Int] = Array(3)
scala> d.intersect(b)
res19: scala.collection.mutable.LinkedList[Int] = LinkedList(3)

5. +：
   在数组前面添加一个元素，并返回新的对象

scala> 100 +: b
res116: Array[Int] = Array(100, 12, 45, 78, 96, 3)

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

scala> b :+ 0
res117: Array[Int] = Array(12, 45, 78, 96, 3, 0)

7. /: 等价 foldLeft(v)(f)
   把v和第一个进行f操作，结果和下一个元素进行相同操作，数组取值从左到右，结果值返回

scala> ( 10/:b)(_-_)  //10-12-45-78-96-3=-224
res28: Int = -224

8. fold(v)(f)
   把v和数组的个第个一元素进行二元运算，得到结果和下一个元素做相操同作，返回结果值

scala> b.fold(10)(_+_)
res19: Int = 244

9. :\ 等价 foldRight(v)(f)
   把v和最后一个进行f操作，结果和下一个元素进行相同操作，数组取值从右到左，结果值返回

scala> (b :\ 10)(_-_)
res27: Int = -58 
/** 运算过程
3-10
96-(3-10)
78-(96-(3-10))
45-(78-(96-(3-10)))
12-(45-(78-(96-(3-10))))=-58
/

10. addString(StringBuilder b)
    将数组中的元素逐个追加到b中 返回StringBuilder

scala> a.addString(a1)
res20: StringBuilder = zhangwangli123123

11. addString(b: StringBuilder, sep: String)
    将数组中的元素逐个追加到b中,每个元素用sep分隔符分开

scala> a.addString(a1,",")
res22: StringBuilder = zhangwangli123123zhang,wang,li,123,123

12. addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
    同上，在首尾各加一个字符串，并指定sep分隔符

scala> a.addString(a1,"{",",","}")
res23: StringBuilder = zhangwangli123123zhang,wang,li,123,123{zhang,wang,li,123,123}

13. aggregate[B](z: ⇒ B)(seqop, combop) B
    聚合计算，柯里化方法

scala> b.par.aggregate(10)(_-_,_-_)

14. par
    返回一个并行实现，产生的并行序列， ParArray

scala> a.par
res289: scala.collection.parallel.mutable.ParArray[Any] = ParArray(zhang, wang, li, 123, 123)

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

scala> var a =Array("zhang","wang","li","123",123)
scala> a.apply(0)
res130: Any = zhang

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

scala> a.canEqual("asd")
res131: Boolean = true

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

val chars = Array('a','b','c')
chars.charAt(2)
res：Char=c

18. clone: Array[T]
    创建一个新的副本

scala> var c = a.clone
c: Array[Any] = Array(zhang, wang, li, 123, 123)

19. collect(fun) Array[B]
    通过执行一个并行计算（偏函数），得到一个新的数组对象

  val fun:PartialFunction[Char,Char] = {
    case 'a' => 'A'
    case x => x
  }
     val chars = Array('a','b','c')
   val newchars = chars.collect(fun)
   
val value = arr.collectFirst({case x:Int => x*100})

20. collectFirst(pf) Option
    在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算

  val fun:PartialFunction[Any,Int] = {
    case x:Int => x*100
  }
scala> a.collectFirst(fun)
res60: Option[Int] = Some(12300)/None

21. combinations(int num) collection.Iterator[Array[T]]
    排列组合，这个排列组合会选出所有指定长度的包含字符不一样的组合

scala> var bb =b.combinations(3)
bb: Iterator[Array[Int]] = non-empty iterator
scala> bb.foreach(x=>println(x.mkString(" ")))
12 45 78
12 45 96
12 45 3
12 78 96
12 78 3
12 96 3
45 78 96
45 78 3
45 96 3
78 96 3

22. permutations collection.Iterator[Array[T]]
    排列组合，他与combinations不同的是，组合中的内容可以相同，但是顺序不能相同

scala> b.permutations.foreach(x=>{print(x.mkString(" "));println()})
12 45 78 96 3
12 45 78 3 96
12 45 96 78 3
12 45 96 3 78
12 45 3 78 96
12 45 3 96 78

23. contains(elem: A1): Boolean
    序列中是否包含指定对象

scala> a.contains("123")
res67: Boolean = true

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

scala> var b =Array(12,45,78,96,3)
scala> var e = Array(45,12)
scala> b.containsSlice(e)
res140: Boolean = true

25. copyToArray(dct,[int1,int2]) Unit
    源数组拷贝到指定数组中，[从目标数组的int1位置开始，把原数组int2开始部分拷贝进去]

scala> var c =new Array[Int](6)
c: Array[Int] = Array(0, 0, 0, 0, 0, 0)
scala> b.copyToArray(c,1,0)
scala> c
res147: Array[Int] = Array(0,12, 45, 78, 96, 3)

26. corresponds(arr)
    判断两个序列长度以及对应位置元素是否符合某个条件。

scala> d.corresponds(c)(_>_)
res81: Boolean = true

27. count
    统计数组中满足条件的元素个数

scala> c.count(p=>p%2==0)
res154: Int = 4

28. distinct Array
    去除当前集合中重复的元素，只保留一个,返回一个新的数组

var arr =Array(1,1,0,4,6,3)
scala> arr.distinct
res93: Array[Int] = Array(1, 0, 4, 6, 3)

29. drop
    将当前序列中前 n 个元素去除后，作为一个新序列返回

scala> a.drop(2)
res96: Array[Any] = Array(li, 123, 123)
scala> a
res97: Array[Any] = Array(zhang, wang, li, 123, 123)

30. dropRight(int)
    将当前序列中前 n 个元素去除后，作为一个新序列返回

scala> var b =Array(12,45,78,96,3)
scala> b.dropRight(3)
res143: Array[Int] = Array(12, 45)

31. dropWhile
    从数组首个开始匹配，去除满足条件的元素（遇到不满足条件则停止）,返回不满足条件的元素集合

scala> b.dropWhile(_%2==0)
res110: Array[Int] = Array(45, 78, 96, 3)

32. filter
    过滤出当前数组满足条件的元素,返回新的数组

scala> b.filter(_%2==0)
res111: Array[Int] = Array(12, 78, 96)

33. filterNot
    过滤出当前数组不满足条件的元素，返回新的数组

scala> b.filterNot(_%2==0)
res112: Array[Int] = Array(45, 3)

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

scala> b.exists(_<10)
res120: Boolean = true
scala> b.exists(_%2 ==0)
res124: Boolean = true

35. endsWith
    判断当前序列是否以某个序列结尾

scala> b.endsWith(Array(78,96,3))
res126: Boolean = true
scala> b.endsWith(List(78,96,3))
res127: Boolean = true

36. startsWith
    判断当前序列是否以某个序列开始

scala> b.startsWith(Array(12,45))
res130: Boolean = true
scala> b.startsWith(Array(13))
res131: Boolean = false

37. find
    找到满足条件的第一个元素，存在就以Some形式返回，不存在就返回None

scala> b.find(_>20)
res132: Option[Int] = Some(45)
scala> b.find(_==0)
res134: Option[Int] = None

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

scala> c.flatMap(x=> 1 to x )
res139: List[Int] = List(1, 1, 2)

39. flatten
    扁平化处理，将二维数组的所有元素联合在一起，形成一个一维数组返回

scala> val dArr = Array(Array(1,2,3),Array(4,5,6))
scala> dArr.flatten
res146: Array[Int] = Array(1, 2, 3, 4, 5, 6)

40. forall
    检测序列中的元素是否全都满足条件，返回true/false

scala> b.forall(_<100)
res154: Boolean = true
scala> b.forall(_<50)
res155: Boolean = false

41. foreach(f)
    遍历序列中的元素，进行操作

scala> a.foreach(x=>print(x+" "))
zhang wang li 123 123

42. groupBy
    按条件分组，匹配条件，返回值是Map类型，每个key对应一个序列

scala> b.groupBy(x=>x match{
      case x if (x<20) => "small"
      case _ => "big"
      })
res163: scala.collection.immutable.Map[String,Array[Int]] =
Map(small -> Array(12, 3), big -> Array(45, 78, 96))

43. groupde(size)
    按指定数量分组，每组size个元素，返回 Iterator[Array[T]]

scala> b.grouped(2).foreach(x=>{print(x.mkString(" "));println()})
12 45
78 96
3

44. hasDefinitedSize
    检查序列是否存在有限的长度，对应Stream这样的流数据，返回值false

scala> a.hasDefiniteSize
res170: Boolean = true

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

scala> a.head
res175: Any = zhang
scala> b.head
res176: Int = 12

46. tail
    返回序列去除第一个元素后的新序列

scala> a.tail
res178: Array[Any] = Array(wang, li, 123, 123)

47. tails
    连续调用tail，每一次结果作为下一次的新序列，直至序列为空，打印一次空值，返回Iterator[Array[Any]]

scala> a.tails.foreach(x=>{print(i+1+" "+x.mkString(" "));println()})
1 zhang wang li 123 zhao
1 wang li 123 zhao
1 li 123 zhao
1 123 zhao
1 zhao
1

48. last
    返回序列最后一个元素，如果序列为空，将引发错误

scala> a.last
res184: Any = 123
scala> b.last
res185: Int = 3

49. init
    返回序列去除最后一个元素后的新序列

scala> a.init
res186: Array[Any] = Array(zhang, wang, li, 123)
scala> b.init
res187: Array[Int] = Array(12, 45, 78, 96)

50. headOption
    返回序列第一个元素的Option类型，scala.Some，如果序列是空，返回None；通过get方法获取Some类型值

scala> b.headOption
res181: Option[Int] = Some(12)

51. lastOption
    返回当前序列中最后一个对象

scala> b.lastOption
res262: Option[Int] = Some(3)

52. indexOf
    返回目标元素在序列指定索引之后的第一个索引位置，没有就返回-1

scala> a.indexOf(13)
res182: Int = -1
scala> a.indexOf(123)
res183: Int = 4

53. lastIndexOf（elem,index）
    返回序列中[index开始之后的]最后一个等于elem的索引值，没有就返回-1

scala> (b:+45).lastIndexOf(45)
res254: Int = 5

54. indexOfSlice(that，index)
    检测当前序列中是否包含另一个序列（that），[从指定索引出开始]并返回第一个匹配出现的元素的索引，没有就返回-1

scala> a.indexOfSlice(Array("li","123"))
res198: Int = 2

55. lastIndexOfSlice(that,end)
    返回当前序列中最后一次出现目标序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找，没有就返回-1

scala> var bb1 = b.union(Array(12,45,20,60,12,45))
bb1: Array[Int] = Array(12, 45, 78, 96, 3, 12, 45, 20, 60, 12, 45)
scala> bb1.lastIndexOfSlice(Array(12,45),7)
res256: Int = 5

56. indexWhere(p,index)
    返回当前序列中满足条件的第一个元素的索引,可以指定开始位置，没有就返回-1

scala> b.indexWhere(_>50)
res204: Int = 2
scala> b.indexWhere({x:Int => x> 20})
res205: Int = 1
scala> b.indexWhere({x:Int => x> 20},3)
res208: Int = 3

57. lastIndexWhere(p,end)
    返回当前序列中最后一个满足条件 p 的元素的索引，可以指定在 end 之前（包括）的元素中查找，没有就返回-1

scala> b.lastIndexWhere({x:Int=>x<50})
res260: Int = 4
scala> b.lastIndexWhere({x:Int=>x<50},3)
res261: Int = 1

58. indices collection.immutable.Range
    返回当前序列索引集合

scala> b.indices
res210: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)
scala> c.indices
res211: scala.collection.immutable.Range = Range(0, 1)

59. inits
    对集合中的元素进行init操作，把返回值作为新序列开始第二次init操作，最后一个为空值

scala> b.inits.foreach(x=>println(x.mkString(" ")))
12 45 78 96 3
12 45 78 96
12 45 78
12 45
12
//有一行空行

60. isDefinedAt(index)
    判断序列中是否存在索引

scala> a.isDefinedAt(5)
res217: Boolean = false
scala> a.isDefinedAt(0)
res218: Boolean = true

61. isEmpty
    判断集合是否为空，为空返回true

scala> var c2 =new Array[String](0)
c2: Array[String] = Array()
scala> c2.isEmpty
res231: Boolean = true
scala> a.isEmpty
res232: Boolean = false

62. nonEmpty
    判断序列非空，集合非空返回true

scala> a.nonEmpty
res282: Boolean = true

63. isTraversableAgain
    判断序列是否可以反复遍历，Iterators 返回false，常规数组集合返回true

64. iterator
    对序列中的每个元素产生一个 iterator

scala> a.iterator
res245: Iterator[Any] = non-empty iterator

65. toIterator
    同 iterator 方法，返回一个迭代器

scala> b.iterator.foreach(x=>print(x+" "))
12 45 78 96 3

66. reverseIterator
    反向生成迭代器,collection.Iterator[T]

scala> b.reverseIterator.foreach(x=>print(x+" "))
3 96 78 45 12

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

scala> a.length
res263: Int = 5

68. size
    返回当前序列中元素个数

scala> a.length
res263: Int = 5

69. lengthCompare(len)
    比较序列的长度和参数 len，返回序列长度与参数len的差值

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

70. map
    对序列中的元素进行相同操作，返回新的序列

scala> b.map({x:Int => x*x})
res269: Array[Int] = Array(144, 2025, 6084, 9216, 9)

71. reverseMap
    序列元素进行同一操作,逆序输出

scala> b.reverseMap({x:Int=>x*2})
res335: Array[Int] = Array(6, 192, 156, 90, 24)

72. max
    返回序列中最大的元素

scala> b.max
res274: Int = 96

73. min
    返回序列中最小的元素

scala> b.min
res275: Int = 3

74. minBy
    返回序列中第一个符合条件的最大的元素

75. mkString(str,sep,end)
    将所有元素组合成一个字符串,[指定开始符号，分割符号，结束符号]

scala> b.mkString(" ")
res280: String = 12 45 78 96 3

scala> b.mkString("{"," ","}")
res281: String = {12 45 78 96 3}

76. padTo(len,elem)
    后补齐序列，如果当前序列长度小于 len，产生一个新的序列长度是 len，多出的几个位值填充 elem，否则返回当前序列

scala> c.padTo(5,5)
res285: List[Int] = List(1, 2, 5, 5, 5)
scala> a.padTo(3,5)
res287: Array[Any] = Array(zhang, wang, li, 123, 123)

77. partition
    按条件将序列拆分成两个新序列，满足条件的放第一个序列中，其余放第二个序列中，返回(Array,Array)

scala> b.partition(_>50)
res291: (Array[Int], Array[Int]) = (Array(78, 96),Array(12, 45, 3))

78. patch（from,that,replaced）
    批量替换，从原序列第from个元素开始，后面的replaced数量个元素，替换成序列that，返回这个新序列

scala> a.patch(3,Array("change","111","do"),1)
res296: Array[Any] = Array(zhang, wang, li, change, 111, do, 123)

79. prefixLength§
    给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p，匹配序列满足条件的元素，遇到不满足的元素则停止，统计当前满足条件的元素个数

scala> b.prefixLength(_%2==0)
res308: Int = 1
scala> b.prefixLength(_>20)
res309: Int = 0
scala> b.prefixLength(_>10)
res310: Int = 4

80. product

返回所有元素乘积的值
scala> b.product
res313: Int = 12130560
scala> d.product
res312: Int = 12

81. sum
    返回所有元素累加的值

scala> b.sum
res314: Int = 234
scala> c.sum
res315: Int = 3

82. reduce
    序列元素顺序执行操作，每一次执行结果和下一个元素进行同一操作

scala> b.reduce(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res321: Int = 234

scala> b.reduce(_+_)
res322: Int = 234

83. reduceLeft
    序列元素从左向右执行相同操作，每一次结果和下一个元素进行同一操作

scala> b.reduceLeft(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res326: Int = 234

84. reduceRight
    序列元素从右向左执行相同操作，每一次结果和下一个元素进行同一操作

scala> b.reduceRight(seqno)
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res325: Int = 234

85. reduceLeftOption

计算Option
scala> b.reduceLeftOption(seqno)
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res329: Option[Int] = Some(234)

86. reduceRightOption
    计算Option

scala> b.reduceRightOption(seqno)
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res330: Option[Int] = Some(234)

87. reverse
    返回新的反转序列

scala> b.reverse
res327: Array[Int] = Array(3, 96, 78, 45, 12)

88. sameElements(that )
    判断两个序列是否顺序和对应位置上的元素都一样

b1: Array(1, 2, 3, 4)
b2:List(1,2,3,4)
c: List(1, 2)
scala> b1.sameElements(c)
res347: Boolean = false
scala> c.sameElements(b1)
res348: Boolean = false

scala> b2.sameElements(b1)
res349: Boolean = true

89. scan(value)(op)
    序列元素顺序执行操作，每一次执行结果和下一个元素进行同一操作，每一步计算结果放到新的集合中返回

scala> b.scan(0)(seqno)
seq_exp=0+12
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res367: Array[Int] = Array(0, 12, 57, 135, 231, 234)

90. scanLeft
    从左向右计算

scala> b.scanLeft(0)(seqno)
seq_exp=0+12
seq_exp=12+45
seq_exp=57+78
seq_exp=135+96
seq_exp=231+3
res368: Array[Int] = Array(0, 12, 57, 135, 231, 234)

91. scanRight
    从右向左计算

scala> b.scanRight(0)(seqno)
seq_exp=3+0
seq_exp=96+3
seq_exp=78+99
seq_exp=45+177
seq_exp=12+222
res369: Array[Int] = Array(234, 222, 177, 99, 3, 0)

92. segmentLength(p,from)
    从序列的 from 处开始向后查找，所有满足 p 的连续元素的长度

scala> b.segmentLength(_%2==0,0)
res35: Int = 1

93. seq
    产生一个当前数组的可变数组视图，collection.mutable.IndexedSeq[T]

scala> a.seq
res370: scala.collection.mutable.IndexedSeq[Any] =
WrappedArray(zhang, wang, li, 123, 123)

94. slice(from,until)
    取出当前序列中，下标from 到 until （不含）之间的序列

scala> a.slice(1,3)
res371: Array[Any] = Array(wang, li)

95. sliding(size,step)
    序列按长度size取值，往后移动step再次取值，返回新数组，最终组成一个新的集合返回，当剩余元素不够 size 数，则停止，返回类型collection.Iterator[Array[T]]

scala> b.sliding(4,2)
res381: Iterator[Array[Int]] = non-empty iterator
scala> b.sliding(4,2).foreach(x=>{print(x.mkString(" "));println()})
12 45 78 96
78 96 3

96. sortBy(f)
    序列按指定排序规则排序。返回新的序列

scala> b.sortBy({x:Int=>x})
res384: Array[Int] = Array(3, 12, 45, 78, 96)
scala> b.sortBy({x:Int=> 10-x})
res386: Array[Int] = Array(96, 78, 45, 12, 3)

97. sortWith
    自定义排序方法

scala> b.sortWith(_.compareTo(_)>0)
res393: Array[Int] = Array(96, 78, 45, 12, 3)			

98. sorted()
    使用默认的排序规则对序列排序,升序

scala> b.sorted
res387: Array[Int] = Array(3, 12, 45, 78, 96)

99. span
    分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，
    之前的元素放到第一个集合，其它的放到第二个集合，返回类型(Array[T], Array[T])

scala> b.span(_>20)
res395: (Array[Int], Array[Int]) = (Array(),Array(12, 45, 78, 96, 3))

100. splitAt(n)
     从指定位置开始，把序列拆分成两个集合，返回类型(Array[T], Array[T])

scala> b.splitAt(3)
res396: (Array[Int], Array[Int]) = (Array(12, 45, 78),Array(96, 3))

101. stringPrefix
     返回 toString 结果的前缀

scala> c.toString
res404: String = List(1, 2)
scala> c.stringPrefix
res403: String = List
scala> b.toString
res401: String = [I@6a1562d6
scala> b.stringPrefix
res399: String = [I
scala> a.toString
res402: String = [Ljava.lang.Object;@3675bbaf
scala> a.stringPrefix
res400: String = Object;

102. subSequence(start,end)
     返回 start 和 end (不含)间的字符序列，返回类型CharSequence

scala>     val chars = Array('a','b','c','d')
chars: Array[Char] = Array(a, b, c, d)
scala> chars.subSequence(0,2)
res408: CharSequence = ab

103. take(int)
     返回当前序列中前 n 个元素组成的序列

scala> a.take(2)
res410: Array[Any] = Array(zhang, wang)

104. takeRight(int)
     返回当前序列中，从右边开始，选择 n 个元素组成的序列

scala> a.takeRight(3)
res411: Array[Any] = Array(li, 123, 123)

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

scala> b.takeWhile(_>10)
res413: Array[Int] = Array(12, 45, 78, 96)

106. toArray
     转换成 Array 类型

107. toVector
     数组转换为Vector类型

scala> a.to
res414: scala.collection.immutable.IndexedSeq[Any] = Vector(zhang, wang, li, 123, 123)

108. toBuffer
     转换成 Buffer 类型，ArrayBuffer

scala> a.toBuffer
res425: scala.collection.mutable.Buffer[Any] = ArrayBuffer(zhang, wang, li, 123, 123)

109. toList
     返回List集合

scala> a.toList
res427: List[Any] = List(zhang, wang, li, 123, 123)

110. transpose
     矩阵转换，二维数组行列转换，返回类型 Array[Array[U]]

val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
chars: Array[Array[String]] = Array(Array(a, b), Array(c, d), Array(e, f))
a b
c d
e f

scala> chars.transpose
res430: Array[Array[String]] = Array(Array(a, c, e), Array(b, d, f))
a c e
d b f

111. unzip
     将含有两个元组的数组，第一个元素取出组成一个序列，第二个元素组成一个序列，返回类型 (Array[T1], Array[T2])

val chars = Array(("a","b"),("c","d"))
chars: Array[(String, String)] = Array((a,b), (c,d))
scala> chars.unzip
res433: (Array[String], Array[String]) = (Array(a, c),Array(b, d))
scala> var chars=Array((1,4),(2,3))
chars: Array[(Int, Int)] = Array((1,4), (2,3))
scala> chars.unzip
res438: (Array[Int], Array[Int]) = (Array(1, 2),Array(4, 3))

112. unzip3
     将含有三个元组的数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列，返回类型(Array[T1], Array[T2],Array[T3])

scala> val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
chars: Array[(String, String, String)] = Array((a,b,x), (c,d,y), (e,f,z))
scala> chars.unzip3
res439: (Array[String], Array[String], Array[String]) = 
(Array(a, c, e),Array(b, d, f),Array(x, y, z))

scala> val chars = Array((1,"b","x"),(2,"d","y"),(1,"f","z"))
chars: Array[(Int, String, String)] = Array((1,b,x), (2,d,y), (1,f,z))
scala> chars.unzip3
res441: (Array[Int], Array[String], Array[String]) = 
Array(1, 2, 1),Array(b, d, f),Array(x, y, z))

113. update(int,T)
     将原数组序列中 i 索引处的元素更新为 x

scala> a.update(4,"zhao")
scala> a
res461: Array[Any] = Array(zhang, wang, li, 123, zhao)

114. updated(index,elem)
     将序列中 i 索引处的元素更新为 x ,并返回替换后的新数组

scala> a.updated(3,"chang")
res462: Array[Any] = Array(zhang, wang, li, chang, zhao)
scala> a
res463: Array[Any] = Array(zhang, wang, li, 123, zhao)

115. view(from,until)
     返回 from 到 until 间的序列，不包括 until 处的元素，返回类型IndexedSeqView[T, Array[T]]

scala> b.view(1,4)
res32: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)

116.withFilter
按条件过滤序列,滤出符合条件的元素，返回类型为scala.collection.generic.FilterMonadic

scala> b.withFilter(_%2==0)
res31: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@6b7c4734

117. zip(that)
     将两个序列对应位置上的元素组成一个pair序列，直至某个序列元素结束

scala> a.zip(b)
res471: Array[(Any, Int)] = Array((zhang,20), (wang,45), (li,78), (123,96), (zhao,3))

118. zipAll(that,thisElem，thatElem)
     将两个序列对应位置上的元素组成一个pair序列，如果当前序列短，空出的填充为 thisElem，如果 that 短，填充为 thatElem

scala> a.zipAll(c,"a","c")
res476: Array[(Any, Any)] = Array((zhang,1), (wang,2), (li,c), (123,c), (zhao,c))
scala> c.zipAll(a,"c","a")
res477: List[(Any, Any)] = List((1,zhang), (2,wang), (c,li), (c,123), (c,zhao))

119. zipWithIndex
     序列中的每个元素和它的索引组成一个序列,返回类型和当前序列相同

scala> a.zipWithIndex
res478: Array[(Any, Int)] = Array((zhang,0), (wang,1), (li,2), (123,3), (zhao,4))
scala> c.zipWithIndex
res479: List[(Int, Int)] = List((1,0), (2,1))