++
定义:def ++[B]: Array[B]
描述:合并集合,并返回一个新的数组,新数组包含左右两个集合的内容
示例
val a=Array(1,2,3)
val b=Array(1,2,3)
val c = a++b
println(c.mkString(","))
1,2,3,1,2,3
++:
定义:def ++:[B >: A, That]: That
描述:这个方法同上一个方法类似,两个加号后面多了一个冒号,但是不同的是右边操纵数的类型决定着返回结果的类型
示例:Array 和 List 结合,返回结果是 List 类型
val a=List(1,2)
val b=scala.collection.mutable.LinkedList(3,4)
val c = a++:b
println("c的类型为:"+c.getClass)
println(c.mkString(","))
c的类型为:class scala.collection.mutable.LinkedList
1,2,3,4
+:
定义:def +:: Array[A]
描述:在数组前面添加一个元素,并返回新的数组对象
示例:
val a=Array(1,2,3,4,5,6,7)
val b=0+:a
println(b.toList)
List(0, 1, 2, 3, 4, 5, 6, 7)
:+
定义:def :+: Array[A]
描述:在数组后面添加一个元素,并返回新的数组对象
示例:
val a=Array(1,2,3,4,5,6,7)
val b=a:+0
println(b.toList)
List(1, 2, 3, 4, 5, 6, 7, 0)
/:
定义:def /:[B]: B
描述:对数组中所有的元素从左向右遍历,进行相同的迭代操作,foldLeft 的简写
示例:
val a=Array(1,2,3,4,5,6,7)
val b=(10/:a)((x,y)=>{println(x+"+"+y);x+y})
println(b)
10+1
11+2
13+3
16+4
20+5
25+6
31+7
38
:\
定义:def :[B]: B
描述:对数组中所有的元素从右向左遍历,进行相同的迭代操作,foldRight 的简写
示例:
val a=Array(1,2,3,4,5,6,7)
val b=(a:\10)((x,y)=>{println(x+"+"+y);x+y})
println(b)
7+10
6+17
5+23
4+28
3+32
2+35
1+37
38
addString(b)
定义:def addString(b: StringBuilder): StringBuilder
描述:将数组中的元素逐个添加到 StringBuilder 中
示例:
val a=Array(1,2,3,4,5,6,7)
val b=new StringBuilder()
a.addString(b)
println(b.toList)
List(1, 2, 3, 4, 5, 6, 7)
addString(b, sep)
定义:def addString(b: StringBuilder, sep: String): StringBuilder
描述:将数组中的元素逐个添加到 StringBuilder 中,每个元素用 sep 分隔符分开
示例:
val a=Array(1,2,3,4,5,6,7)
val b=new StringBuilder()
a.addString(b,",")
println(b)
1,2,3,4,5,6,7
aggregate
定义:def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
描述:聚合计算,aggregate 是柯里化方法,参数是两个方法
示例:为了方便理解,把 aggregate 的两个参数分别封装成两个方法,并把分区和不分区的计算过程分别打印出来
def seq(x:Int,y:Int):Int={
println(s"seq:$x+$y")
x+y
}
def com(x:Int,y:Int):Int={
println(s"com:$x+$y")
x+y
}
//这里方法不能放到main当中,不然会报forward reference extends over definition of value
//不分区
val a=Array(1,2,3,4,5,6,7)
var i = a.aggregate(5)(seq, com)
println(i)
seq:5+1
seq:6+2
seq:8+3
seq:11+4
seq:15+5
seq:20+6
seq:26+7
33
//分区par
val a=Array(1,2,3,4,5,6,7)
var i = a.par.aggregate(5)(seq, com)
println(i)
seq:5+4
seq:5+1
seq:5+6
seq:5+3
seq:5+5
seq:5+2
seq:5+7
com:7+8
com:11+12
com:6+15
com:9+10
com:19+23
com:21+42
63
通过上面的运算不难发现,不分区时,seq 是把初始值顺序和每个元素相加,把得到的结果与下一个元素进行运算。
分区时,seq 是把初始值与每个元素相加,但结果不参与下一步运算,而是放到另一个序列中,由第二个方法 com 进行处理。
上面的过程可以简写为
val c=a.par.aggregate(5)(_+_,_+_)
apply
定义:def apply(i: Int): T
描述:获取指定索引处的元素
示例:
val a=Array(1,2,3,4,5)
val i = a.apply(1)
println(i)
2
canEqual
定义:def canEqual(that: Any): Boolean
描述:判断两个对象是否可以进行比较
示例:基本上所有对象都可以进行比较,我不知道这个方法的意义何在
val a=Array(1,2,3,4,5)
val i = a.apply(1)
println(a.canEqual(i))
true
charAt
定义:def charAt(index: Int): Char
描述:获取 index 索引处的字符,这个方法会执行一个隐式的转换,将 Array[T] 转换为 ArrayCharSequence,只有当 T 为 Char 类型时,这个转换才会发生
示例:
val a=Array('a','b','c')
println(a.charAt(1))
b
clone
定义:def clone(): Array[T]
描述:创建一个副本
示例:
val a=Array('a','b','c')
val b = a.clone()
println(b.mkString(","))
a,b,c
collect
定义:def collect[B](pf: PartialFunction[A, B]): Array[B]
描述:通过执行一个并行计算(偏函数),得到一个新的数组对象
示例:通过下面的偏函数,把数组中的小写的 a 转换为大写的 A
def fun:PartialFunction[Char,Char]={
case 'a'=>'A'
case x=>x
}
val a=Array('a','b','c')
val chars = a.collect(fun)
println(chars.mkString(","))
A,b,c
collectFirst
定义:def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
描述:在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
示例:定义一个偏函数,当被执行对象为 Int 类型时,进行乘 100 的操作
val a=Array(1,2,'a',"b")
val fun:PartialFunction[Any,Int]={
case x:Int=>x*100
}
val b = a.collectFirst(fun)
println(b.get)
//另一种写法,匿名函数
a.collectFirst({case x:Int=>x*100})
100
combinations
定义:def combinations(n: Int): collection.Iterator[Array[T]]
描述: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
定义:def contains[A1 >: A](elem: A1): Boolean
描述:判断序列中是否包含指定对象
示例:
val a=Array("a","b","c")
println(a.contains("a"))
true
containsSlice
定义:def containsSlice[B](that: GenSeq[B]): Boolean
描述:判断当前序列中是否包含另一个序列
示例:
val a=Array("a","b","c")
val b=Array("a","b")
println(a.containsSlice(b))
true
copyToArray(xs)
定义:def copyToArray(xs: Array[A]): Unit
描述:将当前数组元素复制到另一个数组中
示例:
val a=Array("a","b","c")
val b:Array[String]=new Array(5)
a.copyToArray(b)
println(b.mkString(","))
a,b,c,null,null
copyToArray(xs, start)
定义:copyToArray(xs: Array[A], start: Int): Unit
描述:将当前数组元素复制到另一个数组中,从 start 位置开始复制
示例:
a.copyToArray(b,1) // null,a,b,c,null
copyToArray(xs, start, len)
定义:copyToArray(xs: Array[A], start: Int, len: Int): Unit
描述:将当前数组元素复制到另一个数组中,从 start 位置开始复制,长度为 len
示例:
a.copyToArray(b,1,2) // null,a,b,null,null
copyToBuffer
定义:def copyToBuffer[B >: A](dest: Buffer[B]): Unit
描述:将数组中的元素复制到 Buffer 中
示例:
val a=Array("a","b","c")
val b:ArrayBuffer[String]=ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(","))
a,b,c
corresponds
定义:def corresponds[B](that: GenSeq[B])(p: (T, B) ⇒ Boolean): Boolean
描述:判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true,则返回 true
示例:下面代码检查 a 和 b 长度是否相等,并且 a 中元素是否小于 b 中对应位置的元素
val a=Array(1,2,3,4)
val b=Array(5,6,7,8)
println(a.corresponds(b)(_<_))
true
count
定义:def count(p: (T) ⇒ Boolean): Int
描述:符合条件的元素个数
示例:下面代码统计数组中大于 2 的元素个数
val a=Array(1,2,3,4)
println(a.count(x=>x>2))
2
diff
定义:def diff(that: collection.Seq[T]): Array[T]
描述:计算当前数组与另一个数组的差集,即将当前数组中没有在另一个数组中出现的元素返回
示例:
val a=Array(1,2,3,4)
val b=Array(3,4,5,6)
val c = a.diff(b)
println(c.mkString(","))
1,2
distinct
定义:def distinct: Array[T]
描述:去除当前集合中重复的元素,只保留一个
示例:
val a=Array(1,2,3,4,1,2,5,6,4)
val b=a.distinct
println(b.mkString(","))
1,2,3,4,5,6
drop
定义:def drop(n: Int): Array[T]
描述:将当前数组中前 n 个元素去除,返回一个新数组
示例:
val a=Array(1,2,3,4,1,2,5,6,4)
val b=a.drop(2)
println(b.mkString(","))
3,4,1,2,5,6,4
dropRight
定义:def dropRight(n: Int): Array[T]
描述:功能同 drop,去掉尾部的 n 个元素
示例:
val a=Array(1,2,3,4,1,2,5,6,4)
val b=a.dropRight(2)
println(b.mkString(","))
1,2,3,4,1,2,5
dropWhile
定义:def dropWhile(p: (T) ⇒ Boolean): Array[T]
描述:去除当前数组中符合条件的元素,返回剩余的数组,这个需要一个条件,就是从当前数组的第一个元素起,就要满足条件,直到碰到第一个不满足条件的元素结束(即使后面还有符合条件的元素),否则返回整个数组
示例:下面去除数组 a 中大于 2 的元素,第一个元素 3 满足,它后面的元素 2 不满足,所以返回 (2,3,4)
val a=Array(1,2,3,4)
val b=a.dropWhile(x=>x<2)
println(b.mkString(","))
如果数组 a 是 (1,2,3,4),第一个元素就不满足条件,则返回整个数组 (1,2,3,4)
val a=Array(1,2,3,4)
val b=a.dropWhile(x=>x>2)
println(b.mkString(","))
1,2,3,4
endsWith
定义:def endsWith[B](that: GenSeq[B]): Boolean
描述:判断当前序列是否以某个序列结尾
示例:
val a=Array(1,2,3,4)
val b=Array(4)
println(a.endsWith(b))
true
exists
定义:def exists(p: (T) ⇒ Boolean): Boolean
描述:判断当前数组是否包含符合条件的元素
示例:
val a=Array(1,2,3,4)
println(a.exists(x=>x>2))
true
filter
定义:def filter(p: (T) ⇒ Boolean): Array[T]
描述:取得当前数组中符合条件的元素,组成新的数组返回
示例:
val a=Array(1,2,3,4)
println(a.filter(x=>x>2).mkString(","))
3,4
find
定义:def find(p: (T) ⇒ Boolean): Option[T]
描述:查找第一个符合条件的元素,返回 Option
示例:
val a=Array(1,2,3,4)
println(a.find(x=>x>2))
Some(3)
flatMap
定义:def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
描述:对当前序列的每个元素进行操作,结果放入新序列返回,参数要求是 GenTraversableOnce 及其子类
示例:
val a=Array(1,2,3,4)
println(a.flatMap(x=>1 to x).mkString(","))
1,1,2,1,2,3,1,2,3,4
flatten
定义:def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
描述:扁平化,将二维数组的所有元素组合在一起,形成一个一维数组返回
示例:
val a=Array(Array(1,2),Array(2,3))
println(a.flatten.mkString(","))
1,2,2,3
fold
定义:def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
描述:对序列中的每个元素进行二元运算,和 aggregate 有类似的语义,但执行过程有所不同
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqnp=$x+$y")
x+y
}
val a=Array(1,2,3,4,5)
val b = a.fold(5)(seqno)
println(b)
seqnp=5+1
seqnp=6+2
seqnp=8+3
seqnp=11+4
seqnp=15+5
20
//分区
def seqno(x:Int,y:Int):Int={
println(s"seqnp=$x+$y")
x+y
}
val a=Array(1,2,3,4,5)
val b = a.par.fold(5)(seqno)
println(b)
seqnp=5+3
seqnp=5+2
seqnp=5+1
seqnp=5+5
seqnp=6+7
seqnp=5+4
seqnp=9+10
seqnp=8+19
seqnp=13+27
40
foldLeft
定义:def foldLeft[B](z: B)(op: (B, T) ⇒ B): B
描述:从左到右计算,简写方式:def /:[B](z: B)(op: (B, T) ⇒ B): B
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqnp=$x+$y")
x+y
}
val a=Array(1,2,3,4,5)
val b = a.foldLeft(5)(seqno) //简写(5/:a)(_+_)
println(b)
foldRight
定义:foldRight[B](z: B)(op: (B, T) ⇒ B): B
描述:从右到左计算,简写方式:def :[B](z: B)(op: (T, B) ⇒ B): B
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqnp=$x+$y")
x+y
}
val a=Array(1,2,3,4,5)
val b = a.foldRight(5)(seqno) //简写(a/:5)(_+_)
println(b)
seqnp=5+5
seqnp=4+10
seqnp=3+14
seqnp=2+17
seqnp=1+19
20
forall
定义:def forall(p: (T) ⇒ Boolean): Boolean
描述:检测序列中的元素是否都满足条件 p,如果序列为空,则返回 true
示例:
val a=Array(1,2,3,4,5)
println(a.forall(x=>x>2))
false
foreach
定义:def foreach(f: (A) ⇒ Unit): Unit
描述:遍历序列中的元素,进行 f 操作
示例:
val a=Array(1,2,3,4,5)
a.foreach(x=>println(x*2))
2
4
6
8
10
groupBy
定义:def groupBy[K](f: (T) ⇒ K): Map[K, Array[T]]
描述:按条件分组,条件由 f 匹配,返回值是 Map 类型,每个 key 对应一个数组
示例:把数组中小于 3 的元素分到一组,其他元素的分到另一组,返回 Map[String, Array[Int]]
val a=Array(1,2,3,4,5)
val b=a.groupBy(x=>x match{
case x if(x<3)=>"small"
case _=>"big"
})
for (elem <- b) {
println(elem._1,elem._2.mkString("{",",","}"))
}
(small,{1,2})
(big,{3,4,5})
grouped
定义:def grouped(size: Int): collection.Iterator[Array[T]]
描述:按指定数量分组,每组有 size 个元素,返回一个迭代器
示例:
val a=Array(1,2,3,4,5)
val b=a.grouped(2).toList
b.foreach(x=>println(x.mkString(",")))
1,2
3,4
5
hasDefiniteSize
定义:def hasDefiniteSize: Boolean
描述:检测序列是否存在有限的长度,对应Stream这样的流数据,返回false
或者如果迭代器为空,则为true,否则为false
示例:
val a=Array(1,2,3,4,5)
println(a.hasDefiniteSize)
true
head
定义:def head: T
描述:返回序列的第一个元素,如果序列为空,将引发错误
示例:
val a=Array(1,2,3,4,5)
println(a.head)
1
headOption
定义:def headOption: Option[T]
描述:返回序列的第一个元素的 Option 类型对象,如果序列为空,则返回 None
示例:
val a=Array(1,2,3,4,5)
println(a.headOption)
Some(1)
indexOf(elem)
定义:def indexOf(elem: T): Int
描述:返回元素 elem 在序列中第一次出现的索引
示例:
val a=Array(1,2,3,4,5)
println(a.indexOf(2))
1
indexOf(elem, from)
定义:def indexOf(elem: T, from: Int): Int
描述:返回元素 elem 在序列中第一次出现的索引,指定从索引 from 开始查找
示例:
val a=Array(1,2,3,4,5)
println(a.indexOf(2,2))
-1
indexOfSlice(that)
定义:def indexOfSlice[B >: A](that: GenSeq[B]): Int
描述:检测当前序列中是否包含序列 that,并返回第一次出现该序列的索引
示例:
val a=Array(1,2,3,4,5)
val b=Array(4,5)
println(a.indexOfSlice(b))
3
indexOfSlice(that, from)
定义:def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
描述:检测当前序列中是否包含另一个序列 that,指定从索引 from 开始查找,并返回第一次出现该序列的索引
示例:
val a=Array(1,2,3,4,5)
val b=Array(4,5)
println(a.indexOfSlice(b,2))
3
indexWhere
定义:def indexWhere(p: (T) ⇒ Boolean): Int
描述:返回当前序列中第一个满足条件 p 的元素的索引
示例:
val a=Array(1,2,3,4,5)
println(a.indexWhere(x=>x>2))
2
indexWhere(p, from)
定义:def indexWhere(p: (T) ⇒ Boolean, from: Int): Int
描述:返回当前序列中第一个满足条件 p 的元素的索引,指定从索引 from 开始查找
示例:
val a=Array(1,2,3,4,5)
println(a.indexWhere(x=>x>2,2))
2
indices
定义:def indices: collection.immutable.Range
描述:返回当前序列索引集合
示例:
val a=Array(1,2,3,4,5)
val b = a.indices
println(b.mkString(","))
0,1,2,3,4
init
定义:def init: Array[T]
描述:返回当前序列中不包含最后一个元素的序列
示例:
val a=Array(1,2,3,4,5)
val b = a.init
println(b.mkString(","))
1,2,3,4
inits
定义:def inits: collection.Iterator[Array[T]]
描述:对集合中的元素进行 init 迭代操作,该操作的返回值中, 第一个值是当前序列的副本,最后一个值为空,每一步都进行 init 操作,上一步的结果作为下一步的操作对象
示例:
val a=Array(1,2,3,4,5)
val b = a.inits.toList
b.foreach(x=>println("总共:"+b.length+"次 "+x.mkString(",")))
总共:6次 1,2,3,4,5
总共:6次 1,2,3,4
总共:6次 1,2,3
总共:6次 1,2
总共:6次 1
总共:6次
intersect
定义:def intersect(that: collection.Seq[T]): Array[T]
描述:取两个集合的交集
示例:
val a=Array(1,2,3,4,5)
val b=Array(2,5,6,8,4)
println(a.intersect(b).toList)
List(2, 4, 5)
isDefinedAt
定义:def isDefinedAt(idx: Int): Boolean
描述:判断序列中是否存在指定索引
示例:
val a=Array(1,2,3,4,5)
println(a.isDefinedAt(1))
true
isEmpty
定义:def isEmpty: Boolean
描述:判断序列是否为空
示例:
val a=Array(1,2,3,4,5)
val b=new Array[Int](0)
println(a.isEmpty)
println(b.isEmpty)
false
true
isTraversableAgain
定义:def isTraversableAgain: Boolean
描述:判断序列是否可以反复遍历,该方法是 GenTraversableOnce 中的方法,对于 Traversables 一般返回 true,对于 Iterators 返回 false,除非被复写
示例:
val a=Array(1,2,3,4,5)
val b=a.iterator
println(a.isTraversableAgain)
println(b.isTraversableAgain)
true
false
iterator
定义:def iterator: collection.Iterator[T]
描述:生成当前序列的迭代器
示例:
val a=Array(1,2,3,4,5)
val b=a.iterator
println(a.mkString(","))
1,2,3,4,5
last
定义:def last: T
描述:返回序列的最后一个元素,如果序列为空,将引发错误
示例:
val a=Array(1,2,3,4,5)
println(a.last)
5
lastIndexOf(elem)
定义:def lastIndexOf(elem: T): Int
描述:返回元素 elem 在序列中最后一次出现的索引
示例:
val a=Array(1,2,3,4,4,5)
println(a.lastIndexOf(4))
4
lastIndexOf(elem, end)
定义:def lastIndexOf(elem: T, end: Int): Int
描述:返回元素 elem 在序列中最后一次出现的索引,指定在索引 end 之前(包括)的元素中查找
示例:
val a=Array(1,2,3,4,4,5)
println(a.lastIndexOf(4,3))
3
lastIndexOfSlice(that)
定义:def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
描述:检测当前序列中是否包含序列 that,并返回最后一次出现该序列的索引
示例:
val a=Array(1,2,3,4,4,5)
val b=Array(4)
println(a.lastIndexOfSlice(b))
4
lastIndexOfSlice(that, end)
定义:def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
描述:检测当前序列中是否包含序列 that,并返回最后一次出现该序列的索引,指定在索引 end 之前(包括)的元素中查找
示例:
val a=Array(1,2,3,4,4,5)
val b=Array(4)
println(a.lastIndexOfSlice(b,3))
3
lastIndexWhere
定义:ef lastIndexWhere(p: (T) ⇒ Boolean): Int
描述:返回当前序列中最后一个满足条件 p 的元素的索引
示例:
val a=Array(1,2,3,4,4,5)
val b=Array(4)
println(a.lastIndexWhere(x=>x==4))
lastIndexWhere(p, end)
定义:def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
描述:返回当前序列中最后一个满足条件 p 的元素的索引,指定在索引 end 之前(包括)的元素中查找
示例:
val a=Array(1,2,3,4,4,5)
val b=Array(4)
println(a.lastIndexWhere(x=>x==4,3))
lastOption
定义:def lastOption: Option[T]
描述:返回序列的最后一个元素的 Option 类型对象,如果序列为空,则返回 None
示例:
val a=Array(1,2,3,4,4,5)
println(a.lastOption)
Some(5)
length
定义:def length: Int
描述:返回序列元素个数
示例:
val a=Array(1,2,3,4,4,5)
println(a.length)
6
lengthCompare
定义:def lengthCompare(len: Int): Int
描述:比较序列的长度和参数 len,返回序列的长度 - len
示例:
val a=Array(1,2,3,4,4,5)
println(a.lengthCompare(4))
println(a.lengthCompare(6))
println(a.lengthCompare(8))
2
0
-2
map
定义:def map[B](f: (A) ⇒ B): Array[B]
描述:对序列中的元素进行 f 操作,返回生成的新序列
示例:
val a=Array(1,2,3,4,4,5)
val b = a.map(x=>x*10)
println(b.mkString(","))
10,20,30,40,40,50
max
定义:def max: A
描述:返回序列中最大的元素
示例:
val a=Array(1,2,3,4,4,5)
println(a.max)
5
maxBy
定义:def maxBy[B](f: (A) ⇒ B): A
描述:返回序列中符合条件的第一个元素
示例:
val a=Array(1,2,3,4,4,5)
println(a.maxBy(x=>x>2))
3
min
定义:def max: A
描述:返回序列中最小的元素
示例:
val a=Array(1,2,3,4,4,5)
println(a.min)
1
minBy
定义:def minBy[B](f: (A) ⇒ B): A
描述:返回序列中不符合条件的第一个元素
示例:
val a=Array(1,2,3,4,4,5)
println(a.minBy(x=>x<4))
4
mkString
定义:def mkString: String
描述:将序列中所有元素拼接成一个字符串
示例:
val a=Array(1,2,3,4,4,5)
println(a.mkString)
123445
mkString(sep)
定义:def mkString: String
描述:将序列中所有元素拼接成一个字符串,以 sep 作为元素间的分隔符
示例:
val a=Array(1,2,3,4,4,5)
println(a.mkString(","))
1,2,3,4,4,5
mkString(start, sep, end)
定义:def mkString(start: String, sep: String, end: String): String
描述:将序列中所有元素拼接成一个字符串,以 start 开头,以 sep 作为元素间的分隔符,以 end 结尾
示例:
val a=Array(1,2,3,4,4,5)
println(a.mkString("{",",","}"))
{1,2,3,4,4,5}
nonEmpty
定义:def nonEmpty: Boolean
描述:判断序列是否不为空
示例:
val a=Array(1,2,3,4,4,5)
val b=new Array[Int](0)
println(a.nonEmpty)
println(b.nonEmpty)
true
false
padTo
定义:def padTo(len: Int, elem: A): Array[A]
描述:填充序列,如果当前序列长度小于 len,那么新产生的序列长度是 len,多出的几个位值填充 elem,如果当前序列大于等于 len ,则返回当前序列
示例:填充一个长度为 7 的序列,不足位补 8
val a=Array(1,2,3,4,4,5)
val b=a.padTo(9,8)
println(b.mkString(","))
1,2,3,4,4,5,8,8,8
par
定义:def par: ParArray[T]
描述:返回一个并行实现,产生的并行序列不能被修改
示例:
val a=Array(1,2,3,4,4,5)
val b=a.par
println(b.mkString(","))
1,2,3,4,4,5
partition
定义:def partition(p: (T) ⇒ Boolean): (Array[T], Array[T])
描述:按条件将序列拆分成两个数组,满足条件的放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组
示例:下面以序列元素是否是偶数来拆分
val a=Array(1,2,3,4,4,5)
val tuple = a.partition(x=>x%2==0)
println(tuple._1.mkString(","))
println(tuple._2.mkString(","))
2,4,4
1,3,5
patch
定义:def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
描述:批量替换,从原序列的 from 处开始,后面的 replaced 个元素,将被替换成序列 that
示例:从 a 的第二个元素开始,取两个元素,即 2 和 3 ,将这两个元素替换为序列 b
val a=Array(1,2,3,4,4,5)
val b=Array(9,9,9)
val c = a.patch(1,b,2)
println(c.mkString(","))
1,9,9,9,4,4,5
permutations
定义:def permutations: collection.Iterator[Array[T]]
描述:permutations 表示排列,这个排列组合会选出所有排列顺序不同的字符组合,permutations 与 combinations 不同的是,相同的组合考虑排列,对于 “abc”、“cba”,视为不同的组合
示例:
val a=Array("a","b","c")
val b = a.permutations
b.foreach(x=>println(x.mkString(",")))
a,b,c
a,c,b
b,a,c
b,c,a
c,a,b
c,b,a
prefixLength
定义:def prefixLength(p: (T) ⇒ Boolean): Int
描述:给定一个条件 p,返回一个前置数列的长度,这个数列中的元素都满足 p
示例:
val a=Array(1,2,3,4,5,6,8)
println(a.prefixLength(x => x < 3))
2
product
定义:def product: A
描述:返回所有元素乘积的值
示例:
val a=Array(1,2,3,4,5,6,8)
println(a.product)
5760
reduce
定义:def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
描述:同 fold,不需要初始值
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqno:$x+$y")
x+y
}
val a=Array(1,2,3,4,5,6,8)
println(a.reduce(seqno))
seqno:1+2
seqno:3+3
seqno:6+4
seqno:10+5
seqno:15+6
seqno:21+8
29
reduceLeft
定义:def reduceLeft[B >: A](op: (B, T) ⇒ B): B
描述:同 foldLeft,从左向右计算,不需要初始值
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqno:$x+$y")
x+y
}
val a=Array(1,2,3,4,5,6,8)
println(a.reduceLeft(seqno))
seqno:1+2
seqno:3+3
seqno:6+4
seqno:10+5
seqno:15+6
seqno:21+8
29
reduceRight
定义:def reduceRight[B >: A](op: (B, T) ⇒ B): B
描述:同 foldRight,从右向左计算,不需要初始值
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqno:$x+$y")
x+y
}
val a=Array(1,2,3,4,5,6,8)
println(a.reduceRight(seqno))
seqno:6+8
seqno:5+14
seqno:4+19
seqno:3+23
seqno:2+26
seqno:1+28
29
reduceLeftOption
定义:def reduceLeftOption[B >: A](op: (B, T) ⇒ B): Option[B]
描述:同 reduceLeft,返回 Option
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqno:$x+$y")
x+y
}
val a=Array(1,2,3,4,5,6,8)
println(a.reduceLeftOption(seqno))
seqno:1+2
seqno:3+3
seqno:6+4
seqno:10+5
seqno:15+6
seqno:21+8
Some(29)
reduceRightOption
定义:def reduceRightOption[B >: A](op: (T, B) ⇒ B): Option[B]
描述:同 reduceRight,返回 Option
示例:
def seqno(x:Int,y:Int):Int={
println(s"seqno:$x+$y")
x+y
}
val a=Array(1,2,3,4,5,6,8)
println(a.reduceRightOption(seqno))
seqno:6+8
seqno:5+14
seqno:4+19
seqno:3+23
seqno:2+26
seqno:1+28
Some(29)
reverse
定义:def reverse: Array[T]
描述:反转序列
示例:
val a=Array(1,2,3,4,5,6,8)
println(a.reverse.mkString(","))
8,6,5,4,3,2,1
reverseIterator
定义:def reverseIterator: collection.Iterator[T]
描述:生成反向迭代器
示例:
val a=Array(1,2,3,4,5,6,8)
val b = a.reverseIterator
b.foreach(x=>println(x))
8
6
5
4
3
2
1
reverseMap
定义:def reverseMap[B](f: (A) ⇒ B): Array[B]
描述:同 map,方向相反
示例:
val a=Array(1,2,3,4,5,6,8)
val b = a.reverseMap(x=>x*10)
println(b.mkString(","))
80,60,50,40,30,20,10
sameElements
定义:def sameElements(that: GenIterable[A]): Boolean
描述:判断两个序列是否顺序和对应位置上的元素都一样
示例:
val a=Array(1,2,3,4,5,6,8)
val b=Array(1,2,3,4,5,6,8)
val c=Array(1,2,3,4,5,8,6)
println(a.sameElements(b))
println(a.sameElements(c))
true
false
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,6,8)
val b=a.scan(5)(_+_)
println(b.mkString(","))
5,6,8,11,15,20,26,34
scanLeft
定义:def scanLeft[B, That](z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
描述:同 foldLeft,从左向右计算,每一步的计算结果放到一个新的集合中返回
示例:
val a=Array(1,2,3,4,5,6,8)
val b=a.scanLeft(5)(_+_)
println(b.mkString(","))
5,6,8,11,15,20,26,34
scanRight
定义:def scanRight[B, That](z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
描述:同 foldRight,从右向左计算,每一步的计算结果放到(从右向左放)一个新的集合中返回
示例:
val a=Array(1,2,3,4,5,6,8)
val b=a.scanRight(5)(_+_)
println(b.mkString(","))
34,33,31,28,24,19,13,5
segmentLength
定义:def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
描述:从序列的 from 开始向后查找,返回满足条件 p 的连续元素的长度,只返回第一个
示例:
val a=Array(1,2,3,4,5,6,8)
println(a.segmentLength(x => x < 3, 3))
0
seq
定义:def seq: collection.mutable.IndexedSeq[T]
描述:产生一个引用当前序列的 sequential 视图
示例:
val a=Array(1,2,3,4)
val b = a.seq
println(b.mkString(","))
size
定义:def size: Int
描述:返回序列元素个数,同 length
示例:
val a=Array(1,2,3,4)
println(a.size)
4
slice
定义:def slice(from: Int, until: Int): Array[T]
描述:返回当前序列中从 from 到 until 之间的序列,不包括 until 处的元素
示例:
val a=Array(1,2,3,4)
println(a.slice(1,3).mkString(","))
2,3
sliding(size)
定义:def sliding(size: Int): collection.Iterator[Array[T]]
描述:滑动,从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组,最终组成一个新的集合返回,当剩余元素个数不够 size 时,则结束
示例:
val a=Array(1,2,3,4,5,6,7,8)
a.sliding(3).foreach(x=>println(x.mkString(",")))
1,2,3
2,3,4
3,4,5
4,5,6
5,6,7
6,7,8
sliding(size, step)
定义:def sliding(size: Int): collection.Iterator[Array[T]]
描述:从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组,最终组成一个新的集合返回,当剩余元素个数不够 size 时,则结束。该方法可以设置步长 step,每一组元素组合完后,下一组从上一组起始元素位置 + step 后的位置处开始
示例:下面代码,第一组从 1 开始, 第二组从 3 开始,因为步长是 2
val a=Array(1,2,3,4,5,6,7,8)
a.sliding(3,3).foreach(x=>println(x.mkString(",")))
1,2,3
4,5,6
7,8
sortBy
定义:def sortBy[B](f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
描述:按指定的排序规则对序列排序
示例:
val a=Array(8,9,8,5,5,6,2)
println(a.sortBy(x => x).mkString(","))
println(a.sortBy(x => -x).mkString(","))
2,5,5,6,8,8,9
9,8,8,6,5,5,2
sorted
定义:def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]]
描述:使用默认的排序规则对序列排序
示例:
val a=Array(8,9,8,5,5,6,2)
println(a.sorted.mkString(","))
2,5,5,6,8,8,9
span
定义:def span(p: (T) ⇒ Boolean): (Array[T], Array[T])
描述:将序列拆分成两个数组,从第一个元素开始,直到第一个不满足条件的元素为止,其中的元素放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组
示例:
val a=Array(1,2,3,4,5,6,7,8,9,10)
val b = a.span(x=>x<3)
println(b._1.mkString(","))
println(b._2.mkString(","))
1,2
3,4,5,6,7,8,9,10
splitAt
定义:def splitAt(n: Int): (Array[T], Array[T])
描述:从指定位置开始,把序列拆分成两个数组
示例:
val a=Array(1,2,3,4,5,6,7,8,9,10)
val b = a.splitAt(5)
println(b._1.mkString(","))
println(b._2.mkString(","))
1,2,3,4,5
6,7,8,9,10
startsWith(that)
定义:def startsWith[B](that: GenSeq[B]): Boolean
描述:判断序列是否以某个序列开始
示例:
val a=Array(1,2,3,4,5,6,7,8,9,10)
val b = Array(1,2)
println(a.startsWith(b))
true
startsWith(that, offset)
定义:def startsWith[B](that: GenSeq[B], offset: Int): Boolean
描述:判断序列从指定偏移处是否以某个序列开始
示例:
val a=Array(1,2,3,4,5,6,7,8,9,10)
val b = Array(1,2)
println(a.startsWith(b,2))
false
stringPrefix
定义:def stringPrefix: String
描述:返回 类型
示例:
val a="hello"
println(a.stringPrefix)
String
subSequence
定义:def subSequence(start: Int, end: Int): CharSequence
描述:返回 start 和 end 间的字符序列,不包含 end 处的元素
示例:
val a=Array('a','b','c','d')
println(a.subSequence(1,3))
bc
sum
定义:def sum: A
描述:序列求和,元素需为 Numeric[T] 类型
示例:
val a=Array(1,2,3,4,5)
println(a.sum)
15
tail
定义:def tail: Array[T]
描述:返回当前序列中不包含第一个元素的序列
示例:
val a=Array(1,2,3,4,5)
println(a.tail.mkString(","))
2,3,4,5
tails
定义:def tails: collection.Iterator[Array[T]]
描述:同 inits,每一步都进行 tail 操作
示例:
val a=Array(1,2,3,4,5)
a.tails.foreach(x=>println(x.mkString(",")))
1,2,3,4,5
2,3,4,5
3,4,5
4,5
5
//有一行空
take
定义:def take(n: Int): Array[T]
描述:返回当前序列中,前 n 个元素组成的序列
示例:
val a=Array(1,2,3,4,5)
println(a.take(3).mkString(","))
1,2,3
takeRight
定义:def takeRight(n: Int): Array[T]
描述:返回当前序列中,从右边开始,后 n 个元素组成的序列
示例:
val a=Array(1,2,3,4,5)
println(a.takeRight(3).mkString(","))
3,4,5
takeWhile
定义:def takeWhile(p: (T) ⇒ Boolean): Array[T]
描述:返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列
示例:
val a=Array(1,2,3,4,5)
println(a.takeWhile(x=>x<3).mkString(","))
1,2
toArray
定义:def toArray: Array[A]
描述:将序列转换成 Array 类型
toBuffer
定义:def toBuffer[A1 >: A]: Buffer[A1]
描述:将序列转换成 Buffer 类型
toIndexedSeq
定义:def toIndexedSeq: collection.immutable.IndexedSeq[T]
描述:将序列转换成 IndexedSeq 类型
toIterable
定义:def toIterable: collection.Iterable[T]
描述:将序列转换成可迭代的类型
toIterator
定义:def toIterator: collection.Iterator[T]
描述:将序列转换成迭代器,同 iterator 方法
toList
定义:def toList: List[T]
描述:将序列转换成 List 类型
toMap
定义:def toMap[T, U]: Map[T, U]
描述:将序列转转换成 Map 类型,需要被转化序列中包含的元素是 Tuple2 类型
toSeq
定义:def toSeq: collection.Seq[T]
描述:将序列转换成 Seq 类型
toSet
定义:def toSet[B >: A]: Set[B]
描述:将序列转换成 Set 类型
toStream
定义:def toStream: collection.immutable.Stream[T]
描述:将序列转换成 Stream 类型
toVector
定义:def toVector: Vector[T]
描述:将序列转换成 Vector 类型
transpose
定义:def transpose[U](implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
描述:矩阵转置,二维数组行列转换
示例:
val a=Array(Array("a","b"),Array("c","d"))
val b = a.transpose
b.foreach(x=>println(x.mkString(",")))
a,c
b,d
union
定义:def union(that: collection.Seq[T]): Array[T]
描述:合并两个序列,同操作符 ++
示例:
val a=Array(1,2,3)
val b=Array(4,5,6)
println(a.union(b).mkString(","))
1,2,3,4,5,6
unzip
定义:def unzip[T1, T2](implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
描述:将含有两个二元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,返回包含这两个数组的元组
示例:
val a = Array(("a", "b"), ("c", "d"))
val b = a.unzip
println(b._1.mkString(","))
println(b._2.mkString(","))
a,c
b,d
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 a = Array(("a", "b", "x"), ("c", "d", "y"), ("e", "f", "z"))
val b = a.unzip3
println(b._1.mkString(","))
println(b._2.mkString(","))
println(b._3.mkString(","))
a,c,e
b,d,f
x,y,z
update
定义:def update(i: Int, x: T): Unit
描述:将序列中 i 索引处的元素更新为 x
示例:
val a = Array(1,2,3,4)
a.update(1,7)
println(a.mkString(","))
1,7,3,4
updated
定义:def updated(index: Int, elem: A): Array[A]
描述:将序列中 i 索引处的元素更新为 x,并返回替换后的数组
示例:
val a = Array(1,2,3,4)
val b = a.updated(1,7)
println(a.mkString(","))
println(b.mkString(","))
1,2,3,4
1,7,3,4
view
定义:def 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)
println(b.mkString(","))
2,3
withFilter
定义:def 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)
println(b.mkString(","))
3,4
zip
定义:def zip[B](that: GenIterable[B]): Array[(A, B)]
描述:将两个序列对应位置上的元素组成一个元组数组,要求两个序列长度相同
示例:
val a = Array(1,2,3,4)
val b = Array(4,5,6,7,8)
println(a.zip(b).mkString(","))
(1,4),(2,5),(3,6),(4,7)
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)
val b = Array(4,5,6,7,8)
println(a.zipAll(b,"a","b").mkString(","))
(1,4),(2,5),(3,6),(4,7),(a,8)
val a = Array(1,2,3,4)
val b = Array(4,5,6,7,8)
println(b.zipAll(a,"a","b").mkString(","))
(4,1),(5,2),(6,3),(7,4),(8,b)
zipWithIndex
定义:def zipWithIndex: Array[(A, Int)]
描述:序列中的每个元素和它的索引组成一个元组数组
示例:
val a = Array(1,2,3,4)
val b = a.zipWithIndex
println(b.mkString(","))
(1,0),(2,1),(3,2),(4,3)