scala数组、集合函数大全(持续更新中)

++、++:

++和++:都是球两个集合的并集，不同的是：
++看左边集合的类型是什么类型，那么返回的集合就是什么类型
++：看右边集合的类型是什么 类型，那么返回的集合就是什么类型

var a = List(100,200,300)
var b = Array(6,7,8,9,10)
a++b
//返回的是List类型的集合
List[Int] = List(100, 200, 300, 6, 7, 8, 9, 10)
a++:b
//返回的是Array类型的集合
Array[Int] = Array(100, 200, 300, 6, 7, 8, 9, 10)

+:、:+

+:和:+都是在一个集合中添加元素，不同的是
+: 是数字在+号前面，集合在:后面
:+ 是数字在+后面，集合在:前面
可以这么理解：+号跟的是数字，:号跟的是集合

1000+:a
//结果为
List[Int] = List(1000, 100, 200, 300)
a:+500
//结果为
List[Int] = List(100, 200, 300, 500)

/:、\:

对数组中数据进行迭代操作
/: 对数组从左向右遍历， 进行相同的迭代操作 floadLeft
:\对数组从右向左遍历，进行相同的迭代操作 floadRight
是二叉树迭代操作，如下：

var c = Array(1,2,3,4,5)
(10/:c)(_+_)
//结果(((((10+1)+2)+3)+4)+5)
//从左向右进行两两相加
Int = 25
(c:\20)(_+_)
//结果(1+(2+(3+(4+(5+20)))))
//从右向左进行两两相加
Int = 35

addString(b:StringBuilder):StringBuilder

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

var c = Array(1,2,3,4,5)
//定义一个StringBuilder
var g = new StringBuilder
//将数组c添加到g中
c.addString(g)
 //结果
StringBuilder = 12345

addString(b:StringBuilder,sep String):StringBuilder

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

c.addString(g,"|")
 StringBuilder = 1|2|3|4|5

apply(i:Int):T

获得指定索引处的元素

val e = List(1,2,3,4)
e.apply(2)
//结果，等同于e(2)
Int = 3
Array[Int] = Array(1, 2, 3, 4, 5)

charAt(index:Int):Char

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

var h = Array('a','b','c','d')
h.charAt(3)
 //结果
 Char = d

clone():Array[T]

创建一个副本，只是值相等，地址不相等

var c = Array(1,2,3,4,5)
var f = c //f指向c
f(3)=100
c
//发现f中索引为3的元素改变了，c中相同索引的元素也改变了，因为他们指向了相同地址
Array[Int] = Array(1, 2, 3, 100, 5)
var g = c.clone()
g(4)=4
//用clone()这个方法只是值相等

collect(pf: PartialFunction[A, B])：Array[B]

通过执行一个偏函数 ，得到一个新数组

//定义一个将a转成A的偏函数
 var h = Array('a','b','c','d')
 //第一个Char是传进来的参数类型，第二个Char是返回参数的类型
 var test1:PartialFunction[Char,Char] = {
 case 'a' => 'A'
 case x => x
 }
 h.collect(test1)
 //结果为
 Array[Char] = Array(A, b, c, d) 

collectFirst(pf: PartialFunction[T, B])

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

 var pfTest01:PartialFunction[Any,Int] = {
 case x:Int => x*100
 }
 var y = Array('t',2,'a',"b")
 y.collectFirst(pfTest01)
 //结果
 Option[Int] = Some(200)//表示存在200，可以get来获取some中的值
 y.collectFirst(pfTest01).get
 //结果
 Int = 200

另一种写法

y.collectFirst({case x:Int => x* 100})
Option[Int] = Some(200)

combinations(n:Int):collection.Iterator[Array[T]]

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

var y = Array('t',2,'a',"b")
var t = y.combinations(3)
// 返回值是一个迭代器
Iterator[Array[Any]] = non-empty iterator
t.foreach(x=>println(x.mkString(",")))
 //结果
t,2,a
t,2,b
t,a,b
2,a,b 

contains(b):Boolean

判断数组中是否包含指定对象

var y = Array('t',2,'a',"b")
y.contains("b")
//结果为
Boolean = false

containsSlice(that: GenSeq[B]):Boolean

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

 var n =Array("a","b")
 var y = Array('t',2,"a","b")
 y.containsSlice(n)
 //结果为
 Boolean = true

copyToArray(a:Array[A],start:Int):Unit、copyToArray(a:Array[A],start:Int,len:Int)

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

val a = Array(1, 2, 3)
//定义一个长度为10的数组
var b:Array[Int]=new Array(10)
//把数组a复制给b,从索引为3开始
 a.copyToArray(b,3)
 //结果
Array[Int] = Array(0, 0, 0, 1, 2,3, 0, 0, 0, 0)

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

val a = Array(1, 2, 3)
//定义一个长度为10的数组
var b:Array[Int]=new Array(10)
//把数组a复制给b,从索引为3开始
a.copyToArray(b,3,1)
//结果
Array[Int] = Array(0, 0, 0, 1, 2,0, 0, 0, 0, 0)
 

copyToBuffer(B:ArrayBuffer):Unit

将数组中的元素复制到 Buffer 中
ArrayBuffer相当于java中的ArrayList，他是可变的，而Array不可变
需要导包import scala.collection.mutable.ArrayBuffer

//创建一个ArrayBuffer
var b:ArrayBuffer[Int]=new ArrayBuffer()
var a =  Array(1, 2, 3, 100, 5)
c.copyToBuffer(b)
//结果为
scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 100, 5)

corresponds(that: GenSeq[B])(p: (T, B) ⇒ Boolean):Boolean

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

var a = Array(1,2,3,4,5)
var b = Array(1,2,3,4,5)
a.corresponds(b)(_==_)
//结果
Boolean = true

count(p: (T) ⇒ Boolean):Int

统计符合条件的元素个数
下面判断数组元素中能被2整除的元素

var a = Array(1,2,3,4,5)
 a.count({_%2==0}) //相当于a.count({x=>x%2==0})
 Int = 2

【注】如果变量在=>之后只使用一次，那么x=>x就可以用_代替

diff(that: collection.Seq[T]):Array[T]

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

var a = Array(1,2,3,4,5)
var b = Array(1,2,9,7,5)
a.diff(b)
//结果
Array[Int] = Array(3, 4)

distinct:Array[T]

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

var a = Array(1,2,3,4,5,1,5)
a.distinct
//结果
Array[Int] = Array(1, 2, 3, 4, 5)

drop(n:Int):Aray[T]

删除当前数组中的前n个元素，返回一个新数组

var a = Array(1,2,3,4,5)
a.drop(2)
//结果
 Array[Int] = Array(3, 4, 5)

dropRight(n:Int):Array[T]

去掉当前数组尾部的n个元素

var a = Array(1,2,3,4,5)
a.dropRight(3)
//结果
Array[Int] = Array(1, 2, 3)

dropWhile(p: (T) ⇒ Boolean):Array[T]

从第一个元素开始，去除当前数组中符合条件的元素，直到遇到第一个不满足条件的元素（即使后面还有符合条件的元素），返回剩余的数组，如果整个数组都满足条件，那么就返回整个数组

 var a = Array(1,2,3,4,3)
  a.dropWhile(_<3)
  //结果，返回第一个不满足的元素及后面的所有元素
 Array[Int] = Array(3, 4, 3)  

endsWith(that: GenSeq[B]):Boolean

判断当前序列是否以某个序列结尾
是整个序列，而不是序列的末尾元素

 var a = Array("a","b","c","d")
 var b = Array("c","d")
 a.endsWith(b)
 //结果
 Boolean = true

exist(p: (T) ⇒ Boolean):Boolean

判断当前数组是否包含符合条件的元素
参数返回的是boolean类型

var a = Array("a","b","c","d")
a.exists({_=="c"})
//结果
 Boolean = true

filter(T) ⇒ Boolean):Array[T]

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

var a = Array(1,2,3,4,3)
a.filter{_>2}
//结果
Array[Int] = Array(3, 4, 5)

find(p: (T) ⇒ Boolean):Option[T]

查找第一个符合条件的元素，返回存在Some，不存在None

var a = Array(1,2,3,4,5)
a.find{_>3}
//结果
Option[Int] = Some(4)

flatten:Array[U]

扁平化，将集合中的多个数组组合在一起，形成一个新数组返回

var b = Array(Array(1,2,3,4,5),Array(1,2,3),Array(1,2,3))
b.flatten
//结果
Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3, 1, 2, 3)

forall(p: (T) ⇒ Boolean):Boolean

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

scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
	scala> a.forall(x=>x<5)
res26: Boolean = true

flagMap(f: (A) ⇒ B):Array[B]

是map的拓展函数，用于处理 集合套集合，也就是一对一或一对多，最后返回一个聚合，这个集合是把里面每个集合都扁平化了

var a = Array("hadoop easy","scala hard","java easy","hello world")
a.flatMap(x=>x.split(" "))
//结果
 Array[String] = Array(hadoop, easy, scala, hard, java, easy, hello, world)

可以发现通过flatMap方法将里面多个数组扁平化了，变成一个集合，这也是和map的区别

foreach(f: (A) ⇒ Unit):Unit

遍历数列中的元素，进行f操作
【注意】foreach是没有返回值的，只能在函数里面写输出语句来显示

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

groupBy(f: (T) ⇒ K): Map[K, Array[T]]

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

var a = List(1,2,3,4,5)
a.groupBy(x=>x match {
case x if x<3 => "small"
case _ => "big"
})
//结果,返回一个Map集合
res4: scala.collection.immutable.Map[String,List[Int]] = Map(small -> List(1, 2), big -> List(3, 4, 5))

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

按指定数量分组每组有size个元素，返回一个迭代器（迭代器用.next()方法去输出）

var a = List(1,2,3,4,5)
scala> var d = a.grouped(3)
d: Iterator[List[Int]] = non-empty iterator
scala> d.toList
//分成两组list
res6: List[List[Int]] = List(List(1, 2, 3), List(4, 5))

hasDefiniteSize:Boolean

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

var a = List(1,2,3,4,5)
a.hasDefiniteSize
//结果
Boolean = true
//定义一个Stream
 var s = (1 to 1000).toStream
 s: scala.collection.immutable.Stream[Int] = Stream(1, ?)
 s.hasDefiniteSize
 Boolean = false

head:T

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

var s = (1 to 1000).toStream
s: scala.collection.immutable.Stream[Int] = Stream(1, ?)
a.head
//结果
Int = 1

headOption:Option

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

a.headOption
Option[Int] = Some(1)

indexOf(elem: T):Int

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

var a = List(1,2,3,4,5)
a.indexOf(4)
Int = 3

indexOf(elem:T,from:Int):Int

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

 var a = List(1,2,3,4,3,5)
 a.indexOf(3,3)
 //结果
  Int = 4

indexOfSlice(that: GenSeq[B]):Int

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

 var a = List(1, 2, 3, 4, 3,4, 5)
 a.indexOfSlice(List(3,4))
 //结果
 Int = 2  

indexOfSlice(that: GenSeq[B], from: Int):Int

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

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

indexWhere(p: (T) ⇒ Boolean):Int

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

 var a = List(1, 2, 3, 4, 3,4, 5)
 a.indexWhere(x=>x>3)
 //结果
 Int = 3

indexWhere(p: (T) ⇒ Boolean, from: Int):Int

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

 var a = List(1, 2, 3, 4, 3,4, 5)
 a.indexWhere(x=>x>3,4)
 //结果
 Int = 5

indices

返回当前序列索引集合

 var a = List(1, 2, 3, 4, 3,4, 5)
 a.indices
 scala.collection.immutable.Range = Range(0, 1, 2, 3, 4, 5, 6)

init

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

var a = List(1, 2, 3, 4, 3,4, 5)
a.init
//结果
List[Int] = List(1, 2, 3, 4, 3, 4)

inits

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

var a = List(1, 2, 3, 4, 3,4, 5)
a.inits.toList
//结果
List[List[Int]] = List(List(1, 2, 3, 4, 3, 4, 5), List(1, 2, 3, 4, 3, 4), List(1, 2, 3, 4, 3), List(1, 2, 3, 4), List(1, 2, 3), List(1, 2), List(1), List())

intersect(that: collection.Seq[T]):Array[T]

取两个集合的交集

var a = List(1, 2, 3, 4, 3,4, 5)
var b = List(2,3,6,4)
a.intersect(b)
//结果
List[Int] = List(2, 3, 4)

map(f: (A) ⇒ B):Array[B]

遍历数组中的每一个元素，并对每一项执行指定的f方法,返回一个集合

var a = Array("hadoop easy","scala hard","java easy","hello world")
//使用split(" ")将里面每个字符串分割成一个数组
a.map(x=>x.split(" "))
  //结果
Array[Array[String]] = Array(Array(hadoop, easy), Array(scala, hard), Array(java, easy), Array(hello, world)) 

var a = Array(1,2,3,4,5)
a.map{_*2}
//结果返回一个集合
Array[Int] = Array(2, 4, 6, 8, 10)

小试牛刀：用scala函数实现wordcount

var a = Array("java","scala","spark","python","spark","hadoop","java","spark","scala","java","scala")
a.map((_,1)).groupBy(_._1).map(x=>(x._1,x._2.length))
//结果
scala.collection.immutable.Map[String,Int] = Map(java -> 3, hadoop -> 1, spark -> 3, scala -> 3, python -> 1)

map和foreach()的区别

map：返回一个集合
foreach：无返回值

productIterator

将元组变成迭代器，以便foreach遍历

val a = ("haha","hehe",5)
a.productIterator
Iterator[Any] = non-empty iterator
a.productIterator.foreach(x=>println(x))
//结果
haha
hehe
5

mkString: String

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

val a = Array(1, 2, 3, 4)
val b = a.mkString(",")
b: String = 1,2,3,4

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

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

val a = Array(1, 2, 3, 4)
val b = a.mkString("[",",","}")
b: String = [1,2,3,4}

nonEmpty: Boolean

判断序列是否不为空

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

b.nonEmpty
Boolean = false

padTo(len: Int, elem: A): Array[A]

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

//填充一个长度为7的序列不足位补8
val a = Array(1,2,3,4)
val b = a.padTo(7,8)
b: Array[Int] = Array(1, 2, 3, 4, 8, 8, 8)
//填充的的序列小于当前序列，返回当前序列
val b = a.padTo(3,8)
b: Array[Int] = Array(1, 2, 3, 4)

par: ParArray[T]

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

val a = Array(1,2,3,4)
val b = a.par
b: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4)

partitioin(p: (T) ⇒ Boolean): (Array[T], Array[T])

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

val a = Array(1,2,3,4)
val b = a.partition(x=>x%2==0)
b: (Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3))

patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]

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

val a = Array(1,2,3,4)
//从索引1开始，总共2个元素需要被新的序列替换
val b = a.patch(1,Array(6,7,8),2)
b: Array[Int] = Array(1, 6, 7, 8, 4)

permutations: collection.Iterator[Array[T]]

permutations表示排列，这个排列组合会选出所有排列顺序不同的字符组合

permutations和combinations的区别：

combinations(个数)：
permutations：对于 “abc”、“cba”，视为不同的组合

val a = Array("a","b","c")
val b = a.permutations
b: Iterator[Array[String]] = non-empty iterator
b.toList
//结果
List[Array[String]] = List(Array(a, b, c), Array(a, c, b), Array(b, a, c), Array(b, c, a), Array(c, a, b), Array(c, b, a))
//combinations
val b = a.combinations(3)
b: Iterator[Array[String]] = non-empty iterator
//结果
b.toList
List[Array[String]] = List(Array(a, b, c))

prefixLength(p: (T) ⇒ Boolean): Int

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

val a =Array(1,2,3,4,2)
//前缀数列的长度
val b = a.prefixLength(x=>x<3)
b: Int = 2

produce: A

返回所有元素乘积的值

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

reduce(op: (A1, A1) ⇒ A1): A1

同fold，不需要初始值，从左向右进行

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

reduceLeft(op: (B, T) ⇒ B): B

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

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

reduceRight(op: (B, T) ⇒ B): B

同foldRight，从右向左计算，不需要返回值

val a = Array(1, 2, 3, 4)
val b = a.reduceRight((x,y)=>{println(x,y);x+y})
(3,4)
(2,7)
(1,9)
b: Int = 10

reduceLeftOption(op: (B, T) ⇒ B): Option[B]

同reduceLeft，返回Option

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

reduceRightOption(op: (T, B) ⇒ B): Option[B]

同 reduceRight，返回 Option

val a = Array(1, 2, 3, 4)
val b = a.reduceRightOption((x,y)=>{println(x,y);x+y})
(3,4)
(2,7)
(1,9)
b: Option[Int] = Some(10)

reverse: Array[T]

反转序列

val a =Array(1,2,3,4)
val b = a.reverse
b: Array[Int] = Array(4, 3, 2, 1)

reverseIterator: collection.Iterator[T]

反向生成迭代器

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

reverseMap(f: (A) ⇒ B): Array[B]

map+reverse

val a =Array(1,2,3,4)
val b = a.reverseMap(x=>x*10)
b: Array[Int] = Array(40, 30, 20, 10)

sameElements(that: GenIterable[A]): Boolean

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

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

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

scan(z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That

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

val a =Array(1,2,3,4)
val b = a.scan(5)(_+_)
b: Array[Int] = Array(5, 6, 8, 11, 15)

scanLeft(z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

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

val a =Array(1,2,3,4)
val b = a.scanLeft(5)(_+_)
b: Array[Int] = Array(5, 6, 8, 11, 15)

scanRight(z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That

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

val a =Array(1,2,3,4)
val b = a.scanRight(5)(_+_)
b: Array[Int] = Array(15, 14, 12, 9, 5)

//和foldRight的区别
val b = a.foldRight(5)(_+_)
b: Int = 15

segmentLength(p: (T) ⇒ Boolean, from: Int): Int

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

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

seq: collection.mutable.IndexedSeq[T]

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

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

size: Int

返回序列元素个数，同length

slice(from: Int, until: Int): Array[T]

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

val a = Array(1,2,3,4,5)
val b = a.slice(1,3)
b: Array[Int] = Array(2, 3)

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

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

val a = Array(1,2,3,4,5)
val b = a.sliding(2)
b: Iterator[Array[Int]] = non-empty iterator
b.toList
List[Array[Int]] = List(Array(1, 2), Array(2, 3), Array(3, 4), Array(4, 5))

sliding(size: Int,step: Int): Iterator[Array[Int]]

该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始

val a = Array(1,2,3,4,5)
val b = a.sliding(2,2)
b: Iterator[Array[Int]] = non-empty iterator
b.toList
//以为步长step设置为2，所以第二组从3开始
List[Array[Int]] = List(Array(1, 2), Array(3, 4), Array(5))

sortBy(f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]

按照指定的排序规则f对序列排序，默认是升序

//升序
val a = Array(3,1,2,4)
val b = a.sortBy(x=>x)
//降序
val b = a.sortBy(x=>x*(-1))
b: Array[Int] = Array(4, 3, 2, 1)

sorted(implicit ord: math.Ordering[B]): Array[T]]

使用默认的排序规则对序列排序(默认是升序排序)，数字按照大小，字符/字符串按照ASCII码排序

val a = Array(3,1,2,4)
//默认升序排序
val b = a.sorted
b: Array[Int] = Array(1, 2, 3, 4)

//降序排序
val b = a.sorted(Ordering.Int.reverse)
b: Array[Int] = Array(4, 3, 2, 1)

sortWith()(lt: (Int, Int) => Boolean): Array[Int]

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

val a = Array(3,1,2,4)
//升序
val b = a.sortWith(_>_)
b: Array[Int] = Array(4, 3, 2, 1)
//降序
val b =a.sortWith(_<_)
b: Array[Int] = Array(1, 2, 3, 4)

span(p: (T) ⇒ Boolean): (Array[T], Array[T])

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

val a = Array(1, 2, 3, 4)
val b = a.span(x=>x<3)
//返回的是元组
b: (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4))

splitAt(n: Int): (Array[T], Array[T])

从指定位置开始，把序列拆分成两个数组

val a = Array(1, 2, 3, 4)
val b = a.splitAt(2)
b: (Array[Int], Array[Int]) = (Array(1, 2),Array(3, 4))

startsWith(that: GenSeq[B]): Boolean

判断当前序列是否以that序列开始

val a = Array(1, 2, 3, 4)
val b =Array(1,2)
val c = a.startsWith(b)
c: Boolean = true

startsWith(that: GenSeq[B], offset: Int): Boolean

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

val a = Array(1, 2, 3, 4)
val b = Array(2, 3)
val c = a.startsWith(b,1)
c: Boolean = true

stringPrefix:String

返回toString结果的前缀

subsequence(start: Int, end: Int): CharSequence

必须是**字符序列(字符串)**才可以调用，返回start和end间的字符序列，不包含end处的元素

//char类型数组
val a = Array('a','b','c','d')
val b = a.subSequence(1,3)
b: CharSequence = bc
//字符串
val a = "abcd"
b: CharSequence = bc

sum:A

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

val a = Array(1,2,3,4)
val b = a.sum
b: Int = 10

//char数组
val c = Array('a','b','c')
//限定类型为Int
val b:Int = c.sum
b: Int = 294

tail:Array[T]

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

val a = Array(1,2,3,4)
val b = a.tail
b: Array[Int] = Array(2, 3, 4)
 

tails:collection.Iterator[Array[T]]

同inits，每一步都进行tail操作，最后返回的是一个迭代器，迭代器最后一个为空数组

val a = Array(1,2,3,4)
a.tails.foreach(x=>println(x.mkString(",")))
//结果
1,2,3,4
2,3,4
3,4
4

take(n: Int): Array[T]

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

val a = Array(1,2,3,4)
val b = a.take(3)
b: Array[Int] = Array(1, 2, 3)

takeRight(n: Int): Array[T]

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

val a = Array(1,2,3,4)
val b = a.takeRight(3)
b: Array[Int] = Array(2, 3, 4)

takeWhile(p: (T) ⇒ Boolean): Array[T]

返回当前序列中，从第一个元素开始，满足条件p的连续元素组成的数组，如果第一个不满足就返回一个空数组

val a = Array(1,2,3,4)
val b = a.takeWhile(x=>x<3)
b: Array[Int] = Array(1, 2)

val a = Array(3,1,2,4)
//第一个不满足，所以返回一个空数组
val b = a.takeWhile(x=>x<3)
b: Array[Int] = Array()

toArray:Array[A]

将序列转成Array】类型

toBuffer:Buffer[A1]

将序列转换成 Buffer 类型

toIndexSeq:collection.immutable.IndexedSeq[T]

将序列转换成 IndexedSeq 类型

toIterable:collection.Iterable[T]

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

toIterator: collection.Iterator[T]

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

toList:List[T]

toMap:Map[T, U]

需要被转化序列中包含的元素是 Tuple2 类型

toSeq: collection.Seq[T]

toSet: Set[B]

toVector:Vector[T]

将序列转换成Vector类型

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

transpose(implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]

转置矩阵，将二位数组转置

val a = Array(Array(1,2),Array(3,4),Array(5,6))
val b = a.transpose
b: Array[Array[Int]] = Array(Array(1, 3, 5), Array(2, 4, 6))

union(that: collection.Seq[T]): Array[T]

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

val a = Array(1,2)
val b = List(3,4)
val c = a.union(b)
c: Array[Int] = Array(1, 2, 3, 4)
//++看左边序列的类型
val c = b.union(a)
c: List[Int] = List(3, 4, 1, 2)

unzip(implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])

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

val a = Array(("a",1),("b",2))
val b = a.unzip
b: (Array[String], Array[Int]) = (Array(a, b),Array(1, 2))

unzip3(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
b: (Array[String], Array[String], Array[String]) = (Array(a, c, e),Array(b, d, f),Array(x, y, z))

update(i: Int, x: T):Unit

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

val a = Array(1,2,3,4)
a.updated(1,7)
a
Array[Int] = Array(1, 7, 3, 4)

updated(index: Int, elem: A): Array[A]

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

val a = Array(1,2,3,4)
val b = a.updated(1,7)
b: Array[Int] = Array(1, 7, 3, 4)

view(from: Int, until: Int): IndexedSeqView[T, Array[T]]

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

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

withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]

根据条件p过滤元素

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

withFilter与filter的区别

filter返回的是Array类型
withFilter则是不生成新的集合
withFilter将非严格地(即延迟地)将过滤后的值传递到以后的map / flatMap / withFilter调用，保存第二遍通过(过滤)集合
因此，当传递到这些后续方法调用时，它将更有效。
最后结论是，有链式操作的时候，推荐使用withFilter

zip(that: GenIterable[B]): Array[(A, B)]

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

val a = Array(1, 2, 3, 4)
val b = Array(4,3,2,1)
val c = a.zip(b)
c: Array[(Int, Int)] = Array((1,4), (2,3), (3,2), (4,1))

zipALL(that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]

允许两个序列长度不同进行zip操作，长度不足的自动根据值填充，，如果当前序列(调用zipAll的序列)短，不足的元素填充为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)
c: Array[(Int, Int)] = Array((1,5), (2,4), (3,3), (4,2), (5,1), (6,9), (7,9))

val x = Array(1, 2, 3, 4)
val y = Array(6, 5, 4, 3, 2, 1)
val z = x.zipAll(y,8,9)
z: Array[(Int, Int)] = Array((1,6), (2,5), (3,4), (4,3), (8,2), (8,1))

zipWithIndex:Array[(A, Int)]

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

val a = Array('a','b','c','d')
val b = a.zipWithIndex
//结果
b: Array[(Char, Int)] = Array((a,0), (b,1), (c,2), (d,3))