isDefinedAt
判断序列中指定索引是否存在数据。
var a= Array(1, 2, 3, 4, 5)
scala> a.isDefinedAt(1)
res10: Boolean = true
scala> a.isDefinedAt(6)
res11: Boolean = false
isEmpty
判断当前序列是否为空
scala> a.isEmpty
res12: Boolean = false
isTraversableAgain
判断序列是否可以反复遍历,对于Iterators会返回false。
var b=a.grouped(2)
b: Iterator[Array[Int]] = non-empty iterator
scala> b.isTraversableAgain
res16: Boolean = false
Iterator
对序列中的每个元素产生一个iterator
scala> var b=a.iterator
b: Iterator[Int] = non-empty iterator
scala> b.foreach(println)
1
2
3
4
5
last
取得序列中最后一个等于指定元素的位置。
scala> var a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.last
Int = 5
lastIndexOf
取得序列中最后一个等于指定元素的位置。
scala> a.lastIndexOf(2)
Int = 1
可以指定在某截止位置前查找
-def lastIndexOf(elem: T, end: Int): Int
scala> var arr=Array(2,4,1,5,2,6,1,4)
arr: Array[Int] = Array(2, 4, 1, 5, 2, 6, 1, 4)
scala> arr.lastIndexOf(1)
Int = 6
scala> arr.lastIndexOf(1,4)
Int = 2
lastIndexOfSlice
判断当前序列中是否包含指定的序列
scala> var a=Array(1,2,3,2,4,5,1,2,3)
a: Array[Int] = Array(1, 2, 3, 2, 4, 5, 1, 2, 3)
scala> var b=Array(1,2,3)
b: Array[Int] = Array(1, 2, 3)
//最后一次出现的初始位置
scala> a.lastIndexOfSlice(b)
Int = 6
scala> var a=Array(1,2,3,2,4,5,1,2,5)
a: Array[Int] = Array(1, 2, 3, 2, 4, 5, 1, 2, 5)
scala> a.lastIndexOfSlice(b)
Int = 0
lastIndexWhere
返回当前序列中最后一个满足条件的索引
var a=Array(1, 2, 3, 2, 4, 5, 1, 2, 5)
a.lastIndexWhere(_<3)
//结果
Int = 7
-def lastIndexWhere(p: (T) ⇒ Boolean, end: Int): Int
可以指定在end之前(包括end)的元素中查找。
a.lastIndexWhere(_<3,5)
//结果,到索引为5的元素为止
Int = 3
lastOption
返回当前序列最后一个对象
a.lastOption
//Option[Int] = Some(5)
length
返回当前序列中元素个数
a.length
Int = 9
lengthCompare
-def lengthCompare(len: Int): Int
比较序列的长度和参数 len,根据二者的关系返回不同的值,比较规则是:
x < 0 if this.length < len
x == 0 if this.length == len
x > 0 if this.length > len
scala> a.lengthCompare(9)
res48: Int = 0
scala> a.lengthCompare(10)
res49: Int = -1
scala> a.lengthCompare(8)
res50: Int = 1
map
对序列中的元素进行相应的操作。
scala> a
Array[Int] = Array(1, 2, 3, 2, 4, 5, 1, 2, 5)
scala> var b=a.map(_*2)
b: Array[Int] = Array(2, 4, 6, 4, 8, 10, 2, 4, 10)
max
查找序列中最大的元素
a.max
Int = 5
minBy
查找序列中第一个符合条件的最大元素,如果未找到,则返回第一个元素
a.minBy(_>3)
Int = 1
mkString
-def mkString(sep: String): String
将元素组成一个字符串,可以以seq作为元素分隔符
a.mkString
String = 123245125
a.mkString("|")
String = 1|2|3|2|4|5|1|2|5
nonEmpty
判断序列不为空,如果为空返回false,否则返回true。
padTo
def padTo(len: Int, elem: A): Array[A]
后补齐序列,如果当前序列长度小于 len,那么新产生的序列长度是 len,多出的几个位值填充 elem,如果当前序列大于等于 len ,则返回当前序列
scala> var a=Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
//指定位数3小于a的位数,所以不用补
scala> a.padTo(3,2)
res73: Array[Int] = Array(1, 2, 3, 4)
//指定5位,缺少的补上5
scala> a.padTo(5,5)
res74: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.padTo(6,5)
res75: Array[Int] = Array(1, 2, 3, 4, 5, 5)
par
返回一个并行实现,产生的并行序列,不能被修改
a.par
scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4)
partition
将序列拆分成两个新的序列,满足条件的放在第一个,其余的放在第二个
a.partition(_>2)
(Array[Int], Array[Int]) = (Array(3, 4),Array(1, 2))
a.partition(x=>x%2==0)
(Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3))
patch
-def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换,从原序列的 from 处开始,后面的 replaced 数量个元素,将被替换成序列 that
scala> var a=Array(1,2,3,4,5,6,7,8)
a: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8)
scala> var b=Array(11,12,13)
b: Array[Int] = Array(11, 12, 13)
//设置替换1个,把a中的4替换成了b数组
scala> a.patch(3,b,1)
res80: Array[Int] = Array(1, 2, 3, 11, 12, 13, 5, 6, 7, 8)
scala> a.patch(3,b,2)
res81: Array[Int] = Array(1, 2, 3, 11, 12, 13, 6, 7, 8)
//从第三个开始,把后面5个元素替换成b的元素
a.patch(3,b,5)
res82: Array[Int] = Array(1, 2, 3, 11, 12, 13)
permutations
排序组合,组合中的内容可以相同但顺序不能相同。和combinations不同处在于,combinations不允许包含相同的内容。
scala> var a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> var b=a.permutations.toList
b: List[Array[Int]] = 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))
scala> var c=a.combinations(3).toList
c: List[Array[Int]] = List(Array(1, 2, 3))
prefixLength
指前几个连续元素满足一定条件,返回满足条件的元素的数量。
var a=Array(1,2,3)
scala> a.prefixLength(_<2)
res85: Int = 1
scala> a.prefixLength(_<3)
res86: Int = 2
scala> a.prefixLength(_<4)
res87: Int = 3
scala> a.prefixLength(_>2)
res88: Int = 0
product
所有元素的乘积
a.product
Int = 6
reduce
和fold,但是不需要初始值
a.reduce(_+_)
Int = 6
reduceLeft
同reduce,从左向右计算
reduceRight
从右向左计算
scala> a.reduceRight((x,y)=>{println(x,y);x+y})
(2,3)
(1,5)
res95: Int = 6
reduceLeftOption
计算Option,得到一个Option结果
a.reduceLeftOption(_+_)
Option[Int] = Some(6)
reduceRightOption
用法同上,从右开始计算
reverse
反转序列
a.reverse
Array[Int] = Array(3, 2, 1)
reverseIterator
反向生成迭代
a.reverseIterator
Iterator[Int] = non-empty iterator
a.reverseIterator.toList
List[Int] = List(3, 2, 1)
reverseMap
同map的方向相反
a.reverseMap(_*10)
Array[Int] = Array(30, 20, 10)
sameElements
判断两个序列对应位置上的元素和顺序是否一样
var a=Array(1,2,3)
var b=Array(1,2,3)
a.sameElements(b)
Boolean = true
scan
用法同fold,不过scan会把返回的结果全放到一个新的序列中去,fold值返回一个值。’
//定义一个初始值4
scala> a.scan(4)((x,y)=>{println(x,y);x+y})
(4,1)
(5,2)
(7,3)
res105: Array[Int] = Array(4, 5, 7, 10)
scala> a.scan(4)(_+_)
res106: Array[Int] = Array(4, 5, 7, 10)
scanLeft
从左向右计算
scanRight
从右向左计算
segmentLength
def segmentLength(p: (T) ⇒ Boolean, from: Int): Int
从序列的 from 处开始向后查找,所有满足 p 的连续元素的长度
var a=Array(2,3,1,3,4,6,3,7,4)
//小于4的,从第1个元素开始查找,不包括第一个
a.segmentLength(_<4,1)
Int=3