数组、集合函数整理。。。

Array

数组是一种不变的，可索引的数据集合

val arr = Array(1,2,3,4) //声明一个数组对象
//arr: Array[Int] = Array(1, 2, 3, 4)
val first = arr(0)//读取第一个元素
arr(3)=100//第三个元素
val newarr = arr.map(_ * 2) //所有元素乘2
println(newarr.mkString(",")) //打印数组，结果为：2,4,6,200

++

合并集合，并返回一个新的数组，新数组包含左右两个集合的内容

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

++:

这个方法同上一个方法类似，两个加号后面多了一个冒号，但是不同的是右边操纵数的类型决定着返回结果的类型

val a = Array(1,2)
val b = scala.collection.mutable.ListBuffer(3,4)
val c = a++:b
println(c.getClass.getName)

+:

在数组前面添加一个元素，并返回新的数组

val a = List(1, 2)
val b = 1 +: a
println(b.mkString)

:+

在数组后面添加一个元素，并返回新的数组

val a = List(1, 2)
val b = a :+ 9
println(b.mkString)

/:

对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写

val a = List(1,2,3,4)
val b = (10/:a)((x,y)=>x+y)//(10/:a)(_+_)

:\

对数组中的所有元素从右向左遍历，进行相同的迭代操作，foldRight的简写

val a  = List(1,2,3,4)
val b = (a:\10)(_-_)
println(b)

addString(b)

将数组中的元素逐个添加到 StringBuilder 中

addString(b, sep)

将数组中的元素逐个添加到 StringBuilder 中，每个元素用 sep 分隔符分开

a.addString(b,start,sep,end)

输出11,4,3,22 start 和 end 分别加在开头和结尾

val a = List(1,2,3,4)
val b = new StringBuilder()
a.addString(b)
a.addString(b,",")
a.addString(b,"1",",","2")

aggregate

聚合计算 aggregate 是柯里化方法，参数是两个方法

def seq(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
}

val a = List(1,2,3,4)
val b = a.aggregate(5)(seq,combine)
val c = a.par.aggregate(5)(seq,combine)

apply

获取指定索引处的元素

val a = List(1,2,3,4)
val b = a.apply(1)//a.apply(i)同a(i)
println(b) //2

canEqual

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

val a = List()
val b = Array()
println(a.canEqual(b))//true

charAt

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

val chars = Array('a','b','c','d')
println(chars.charAt(2))//c

clone

创建一个副本

val a = Array(1,2,3,4)
val b = a.clone()
print(b.mkString(","))//1,2,3,4

collect

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

collectFirst

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

val fun: PartialFunction[Char, Char] = {
      case 'a' => 'A'
      case x => x
}
val a = Array('a', 'b', 'c','a')
val b = a.collect(fun)
println(b.mkString(","))//A,b,c
println(a.collectFirst(fun).mkString(","))//A

combinations

combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组

val a = Array('a','b','c')
val b = a.combinations(2)//返回一个迭代器
b.foreach(x=> println(x.mkString(",")))
//a,b
//a,c
//b,c

contains

判断序列中是否包含指定对象

val a = List(1,2,3,4)
println(a.contains(1)) //true

containsSlice

判断当前序列中是否包含另一个序列

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

copyToArray(xs)

将当前数组元素复制到另一个数组中

copyToArray(xs, start)

将当前数组元素复制到另一个数组中，从 start 位置开始复制

copyToArray(xs, start, len)

将当前数组元素复制到另一个数组中，从 start 位置开始复制，长度为 len

val a = Array(1,2,3)
val b:Array[Int] = new Array(5)
println(b.mkString(","))//0,0,0,0,0
a.copyToArray(b)
println(b.mkString(","))//1,2,3,0,0
a.copyToArray(b,1)
println(b.mkString(","))//0,1,2,3,0
a.copyToArray(b,1,2)
println(b.mkString(","))//0,1,2,0,0

copyToBuffer

将数组中的元素复制到 Buffer 中

val a = Array(1, 2, 3, 4)
val b: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) // 1,2,3,4

corresponds

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

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

count

统计符合条件的元素个数

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

diff

计算当前数组与另一个数组的差集，即将当前数组中没有在另一个数组中出现的元素返回

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

distinct

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

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

drop

将当前数组中前 n 个元素去除，返回一个新数组

dropRight

功能同 drop，去掉尾部的 n 个元素

dropWhile

去除当前数组中符合条件的元素，返回剩余的数组，这个需要一个条件，就是从当前数组的第一个元素起，就要满足条件，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），否则返回整个数组

val a = Array(1, 2, 3, 4)
val b = a.drop(2)
println(b.mkString(","))
val c = a.dropRight(2)
println(c.mkString(","))
val d = a.dropWhile(x => x > 2)
val e = a.dropWhile(x => x < 2)
println(d.mkString(","))
println(e.mkString(","))
//3,4
//1,2
//1,2,3,4
//2,3,4

endsWith

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

val a = Array(1,2,3,4)
val b = 4
println(a.endsWith(Array.fill(1)(b)))

exists

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

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

filter

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

//filter
val a = Array(1, 2, 3, 4)
val b = a.filter(x => x == 2)
println(b.mkString(","))
//2

find

查找第一个符合条件的元素，返回 Option

val a = Array(1,2,3,4)
println(a.find(_.>(3)))
//Some(4)

flatMap

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

val a = Array("hello world","hello java","hello hao","hello hao nian java")
a.flatMap(_.split(" ")).map(x=>(x,1)).groupBy(_._1).map(x=>(x._1,x._2.length)).toList.sortBy(_._1).foreach(println)

flatten

扁平化处理

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

fold

对序列中的每个元素进行二元操作,类似于agg，执行过程不同

def fun(m:Int,n:Int):Int={
  val s = "seq_exp=%d+%d"
  println(s.format(m,n))
  m+n
}
val a = Array(1,2,3,4)
val b = a.fold(5)(fun) //不分区
println(b)
val  c = a.par.fold(5)(fun)//分区
//seq_exp=5+1
//seq_exp=6+2
//seq_exp=8+3
//seq_exp=11+4
//15
//seq_exp=5+2
//seq_exp=5+4
//seq_exp=5+3
//seq_exp=5+1
//seq_exp=8+9
//seq_exp=6+7
//seq_exp=13+17

foldLeft

从左到右计算

foldRight

从右到左计算

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

val a = Array(1, 2, 3, 4)
val b = a.foldLeft(5)(fun)
val b = a.foldRight(5)(fun)
println(b)
//foldLeft
//seq_exp=5+1
//seq_exp=6+2
//seq_exp=8+3
//seq_exp=11+4

//foldRight
//seq_exp=4+5
//seq_exp=3+9
//seq_exp=2+12
//seq_exp=1+14

forall

检测序列中的元素是否都满足p，如果序列为空，则返回true

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

foreach

遍历序列中的所有元素，进行f操作

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

groupBy

按条件分组，条件由f匹配，返回值是Map类型，每个key对应一个分组

val a = Array(1, 2, 3, 4)
val b = a.groupBy(x => x match {
  case x if x > 3 => "big"
  case _ => "small"
})
b.foreach(x=>println(x._1+": "+x._2.mkString(",")))
//small: 1,2,3
//big: 4

grouped

将指定数组分组，每组有size个元素，返回一个迭代器

val a = Array(1,2,3,4)
val b = a.grouped(3).toList
b.foreach(x=>println("第"+(b.indexOf(x)+1)+"组"+x.mkString(",")))
//第一组 1,2,3
//第二组 4

hadDefiniteSize

检测序列是否具有有效的长度，对应Stream这样的流数据则返回false

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

head

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

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

headOption

返回序列第一个元素的Option类型对象，如果序列为空，将返回None

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

indexOf(elem)

返回元素elem在序列中第一次出现的索引

indexOf(elem,from)

返回元素elem在序列中第一次出现的索引，指定从索引from开始查找

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

indexOfSlice(that)

检测当前序列中是否包含序列that，并返回第一次出现该序列的索引

indexOfSlience(that,from)

检测当前序列中是否包含另一个序列that，指定从索引from开始查找，并返回第一次出现该序列的索引

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

indexWhere§

返回当前序列第一个出现满足条件p的元素的索引

indexWhere(p,from)

返回当前序列第一个出现满足条件p的元素的索引，指定从索引from开始查找

val a = Array(1,2,3,4)
println(a.indexWhere(_.equals(2)))//1
println(a.indexWhere(x => x > 1, 2))//2

indices

返回当前序列索引集合

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

init

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

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

inits

对集合中的元素进行init迭代操作，该操作的返回值中，第一个值是当前序列的副本，最后一个值为空，每一步都进行init操作，上一步的结果作为下一步的操作对象

val a = Array(1, 2, 3, 4)
//    println(a.init.mkString(","))
val b = a.inits.toList
for (i <- 0 until b.length) {
  val s = "第 %d 个值：%s"
  println(s.format(i + 1, Option(b(i).mkString(","))))
}
//第 1 个值：Some(1,2,3,4)
//第 2 个值：Some(1,2,3)
//第 3 个值：Some(1,2)
//第 4 个值：Some(1)
//第 5 个值：Some()

intersect

提取两个集合的交集

val a = Array(1,2,3,4)
val b = Array(2,3,4,5)
a.intersect(b).mkString(",").foreach(print)

isDefinedAt

判断序列中是否存在指定索引

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

isEmpty

判断序列时候为空

val a = Array(1, 2, 3, 4)
val b = Array[Int]()
println(a.isEmpty)		//false
println(b.isEmpty)		//true

isTraversableAgain

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

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

iterator

生成当前序列的迭代器

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

last

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

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

lastIndexOf(elem)

返回元素elem在序列中最后一次出现的索引

lastIndecOf(elem,end)

返回元素elem在序列中最后一次出现的索引，指定在索引end之前(包括)的元素中查找

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

lastIndexOfSlice(that)

检测当前序列是否包含序列that，并返回最后一次出现该序列的索引

lastIndexOfSlice(that,end)

检测当前序列中是否包含序列that，并返回最后一次出现该序列的索引，指定在索引end之前(包括)的元素中查找

val a = Array(1, 2, 3, 4,1,2)
val b = ("a")
val c = Array(1,2)
println(a.lastIndexOfSlice(b))		//-1
println(a.lastIndexOfSlice(c))		//4
println(a.lastIndexOfSlice(c, 3))	//0

lastIndexWhere§

返回当前序列中最后一个满足条件p的元素的索引

lastIndexWhere(p,end)

返回当前序列中最后一个满足条件p的元素的索引，指定在索引end之前(包括)的元素中查找

val a = Array(1, 2, 3, 4,1,2)
println(a.lastIndexWhere(_.>(2)))
println(a.lastIndexWhere(_.>(2), 2))

lastOption

返回序列的最后一个元素的Option类型对象，如果序列为空，则返回None

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

length

返回序列元素的个数

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

lenghCompare(len)

比较序列的长度和参数 len，返回(序列的长度-len)

val a = Array(1, 2, 3, 4, 1, 2)
println(a.lengthCompare(3))
println(a.lengthCompare(6))
println(a.lengthCompare(10))

map

对序列中的元素进行 f 操作，返回生成的新序列

val a = Array(1, 2, 3, 4, 1, 2)
a.map(_.*(10)).mkString(",").foreach(print)
10,20,30,40,10,20

max

返回序列中最大的元素

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

maxBy

返回序列中符合条件的第一个元素

val a = Array(1, 2, 3, 4, 1, 2)
println(a.maxBy(_.>(2)))	//3

min

返回序列中最小的元素

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

minBy

返回序列中不符合条件的第一个元素

val a = Array(1, 2, 3, 4, 1, 2)
println(a.minBy(_.<(2)))		//2

mkString

返回序列中所有元素拼接成一个字符串

mkString(sep)

返回序列中所有元素拼接成一个字符串，以 sep 作为元素间的分隔符

mkString(start,sep,end)

将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾

val a = Array(1, 2, 3, 4, 1, 2)
println(a.mkString)
println(a.mkString(","))
println(a.mkString("start",",","end"))

nonEmpty

判断序列是否不为空

val a = Array(1,2,3,4)
val b = new Array[Int](0)
println(a.nonEmpty)
println(b.nonEmpty)

padTo(len:Int,elem:A)

填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列

val a = Array(1, 2, 3, 4)
val b = a.padTo(10,scala.util.Random.nextInt(100))
println(b.mkString(","))
//1,2,3,4,73,73,73,73,73,73

par

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

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

partition

按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

val a = Array(1, 2, 3, 4)
val b: (Array[Int], Array[Int]) = a.partition(_%2==0)
b._1.mkString(",").foreach(print)
println
b._2.mkString(",").foreach(print)

patch

批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that

val a = Array(1, 2, 3, 4)
val b = Array(36,7,9)
println(a.patch(1, b, 1).mkString(","))

permutations

permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合

val a = Array(1, 2, 3)
a.permutations.toList.foreach(x=> println(x.mkString(",")))
/*
1,2,3
1,3,2
2,1,3
2,3,1
3,1,2
3,2,1*/

prefixLength

给定一个条件 p，返回一个前置数列的长度，这个数列中的元素都满足 p

val a = Array(1, 2, 3, 4)
println(a.prefixLength(x => x < 3)) // 2

product

返回所有元素乘积的值

val a = Array(1, 2, 3, 4)
println(a.product) // 1*2*3*4=24

reduce

同 fold，不需要初始值

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

val a = Array(1,2,3,4)
val b = a.reduce(fun)
println(b)
//seq_exp = 1 + 2
//seq_exp = 3 + 3
//seq_exp = 6 + 4
//10

reduceLeft

同foldLeft，从左向右计算，不需要初始值

reduceLeftOption

同 reduceLeft，返回 Option

reduceRight

同 foldRight，从右向左计算，不需要初始值

reduceRightOption

同 reduceRight，返回 Option

def fun(m:Int,n:Int):Int={
  val s = "seq_exp = %d - %d"
  println(s.format(m, n))
  m - n
}

val a = Array(1,2,3,4)
println(a.reduceLeft(fun))
println(a.reduceLeftOption(fun))
println(a.reduceRight(fun))
println(a.reduceRightOption(fun))
/*
seq_exp = 1 - 2
seq_exp = -1 - 3
seq_exp = -4 - 4
-8
seq_exp = 1 - 2
seq_exp = -1 - 3
seq_exp = -4 - 4
Some(-8)
seq_exp = 3 - 4
seq_exp = 2 - -1
seq_exp = 1 - 3
-2
seq_exp = 3 - 4
seq_exp = 2 - -1
seq_exp = 1 - 3
Some(-2)*/

reserve

反转序列

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

reverseIterator

生成反向迭代器

val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1

reverseMap

同 map，方向相反

al a = Array(1, 2, 3, 4)
val b = a.reverseMap(x => x * 10)
println(b.mkString(",")) // 40,30,20,10

sameElements

判断两个序列是否顺序和对应位置上的元素都一样

val a = Array(1, 2, 3, 4)
val b = a.clone
val c = a.reverse
println(a.sameElements(b))//true
println(a.sameElements(c))//true

scan

同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果

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

scanLeft

同 foldLeft，从左向右计算，每一步的计算结果放到一个新的集合中返回

scanRight

同 foldRight，从右向左计算，每一步的计算结果放到（从右向左放）一个新的集合中返回

val a = Array(1, 2, 3, 4)
val b = a.scanLeft(5)(_ + _)
val c = a.scanRight(5)(_ + _)
println(b.mkString(",")) // 5,6,8,11,15
println(c.mkString(",")) // 15,14,12,9,5

segmentLength

从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个

val a = Array(1,2,3,4)
println(a.segmentLength(_.>(1), 1))	//3

seq

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

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

size

返回序列元素个数，同 length

sliding(size)

滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束

val a = Array(1, 2, 3, 4, 5)
a.sliding(3).toList.foreach(x=> println(x.mkString(",")))
//1,2,3
//2,3,4
//3,4,5

sliding(size, step)

从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始

val a = Array(1, 2, 3, 4, 5)
a.sliding(3,3).toList.foreach(x=> println(x.mkString(",")))

sortBy

按指定的排序规则对序列排序

val a = Array(1,2,3,4)
println(a.sortBy(x => x).mkString(","))//从大到小
println(a.sortBy(x => -x).mkString(","))//从小到大

sorted

使用默认的排序规则对序列排序

val a = Array(3, 2, 1, 4)
val b = a.sorted // 默认升序排列
println(b.mkString(",")) // 1,2,3,4

span

将序列拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，其中的元素放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组

val a = Array(1,3,2,4)
val b = a.span(_.<(2))
println(b._1.mkString(","))
println(b._2.mkString(","))
//1
//3,2,4

splitAt

从指定位置开始，把序列拆分成两个数组(返回的是一个元组)

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

startsWith(that)

判断序列是否以某个序列开始

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

startsWith(that, offset)

判断序列从指定偏移处是否以某个序列开始

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

stringPrefix

返回 toString 结果的前缀

val a = Array(1, 2, 3, 4)
println(a.toString()) // [I@3ab39c39
println(a.stringPrefix) // [I

subSequence

返回 start 和 end 间的字符序列，不包含 end 处的元素(仅用于字符数组)

sum

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

val a = Array(1, 2, 3, 4)
println(a.sum) // 10

tail

返回当前序列中不包含第一个元素的序列

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

tails

同 inits，每一步都进行 tail 操作

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

take

返回当前序列中，前 n 个元素组成的序列

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

takeRight

返回当前序列中，从右边开始，后 n 个元素组成的序列

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

takeWhile

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

val a = Array(1, 2, 3, 4)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2

toArray

将序列转换成 Array 类型

toBuffer

将序列转换成 Buffer 类型

toIndexedSeq

将序列转换成 IndexedSeq 类型

toIterable

将序列转换成可迭代的类型

toIterator

将序列转换成迭代器，同 iterator 方法

toList

将序列转换成 List 类型

toMap

将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型

toSeq

将序列转换成 Seq 类型

toSet

将序列转换成 Set 类型

toStream

将序列转换成 Stream 类型

toVector

将序列转换成 Vector 类型

transpose

矩阵转置，二维数组行列转换

val a = Array(Array(1,2,3),Array(4,5,6),Array(7,8,9))
a.foreach(x=> println(x.mkString(",")))
println("---------------------------------------")
a.transpose.foreach(x=> println(x.mkString(",")))
/*
1,2,3
4,5,6
7,8,9
---------------------------------------
1,4,7
2,5,8
3,6,9
*/

union

合并两个序列，同操作符 ++

unzip

将含有两个二元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，返回包含这两个数组的元组

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

unzip3

将含有三个三元组的数组，每个元组的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返回包含这三个数组的元组

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

update

将序列中 i 索引处的元素更新为 x

updated

将序列中 i 索引处的元素更新为 x，并返回替换后的数组

view

返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素

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

withFilter

根据条件 p 过滤元素

val a = Array(1, 2, 3, 4)
val b = a.withFilter(x => x > 2).map(x => x)
println(b.mkString(",")) // 3,4

zip

将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度相同

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

zipAll

同 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, 8, 9) // (1,5),(2,4),(3,3),(4,2),(5,1),(6,9),(7,9)
println(c.mkString(","))

val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y, 8, 9) // (1,6),(2,5),(3,4),(4,3),(8,2),(8,1)
println(z.mkString(","))

zipWithIndex

序列中的每个元素和它的索引组成一个元组数组

 val a = Array('a', 'b', 'c', 'd')
 val b = a.zipWithIndex
 println(b.mkString(",")) // (a,0),(b,1),(c,2),(d,3)