文章目录
- ++
- ++:
- +:
- :+
- /:
- :\
- addString()
- addString(b, sep)
- aggregate
- apply
- canEqual
- charAt
- clone
- collect
- collectFirst
- combinations
- contains
- containsSlice
- copyToArray(xs)
- copyToArray(xs, start)
- copyToArray(xs, start, len)
- copyToBuffer
- corresponds
- count
- diff
- distinct
- drop
- dropRight
- dropWhile
- endsWith
- exists
- filter
- find
- flatMap
- flattten
- fold
- foldLeft
- foldRight
- forall
- foreach
- groupBy
- grouped
- hasDefiniteSize
- head
- headOption
- indexOf(elem)
- indexOf(elem,from)
- indexOfSlice(that)
- indexWhere(p)
- indexWhere(p, from)
- indices
- init
- inits
- intersect
- isDefinedAt
- isEmpty
- isTraversableAgain
- iterator
- last
- lastIndexOf(elem)
- lastIndexOf(elem, end)
- lastIndexOfSlice(that)
- lastIndexOfSlice(that, end)
- lastIndexWhere(p)
- lastIndexWhere(p, end)
- lastOption
- length
- lengthCompare
- map
- max
- maxBy
- min
- minBy
- mkString
- mkString(sep)
- mkString(start, sep, end)
- nonEmpty
- padTo
- par
- partition
- patch
- permutations
- prefixLength
- product
- reduce
- reduceLeft
- reduceRight
- reduceLeftOption
- reduceRightOption
- reverse
- reverseIterator
- reverseMap
- sameElements
- scan
- scanLeft
- scanRight
- segmentLength
- seq
- size
- slice
- sliding(size)
- sliding(size, step)
- sortBy/sortWith/sorted
- span
- splitAt
- startsWith(that)
- startsWith(that, offset)
- stringPrefix
- subSequence(start,end)
- sum
- tail
- tails
- take
- takeRight
- takeWhile
- toArray
- toBuffer
- toIndexedSeq
- toIterable
- toIterator
- toList
- toMap
- toSeq
- toSet
- toStream
- toVector
- transpose
- union
- unzip
- unzip3
- update
- updated
- view
- withFilter
- zip
- zipAll
- zipWithIndex 序列中的每个元素和它的索引组成一个元组数组
++
合并集合返回一个新的数组
val a=Array(1,2,3,4,5)
val b=List(1,2,8,9)
a++b//Array(1,2,3,4,5,1,2,8,9)
++:
合并集合返回一个新的数组,右边的决定返回集合的类型
val a=Array(1,2,3,4,5)
val b=List(1,2,8,9)
a++:b// List(1, 2, 3, 4, 5, 1, 2, 8, 9)
+:
在集合前面添加一个元素,返回一个新的数组对象
val a=Array(1,2,3,4,5)
1+:a// Array(1, 1, 2, 3, 4, 5)
:+
在集合后面添加一个元素,并返回新的数组
val b=List(1,2,8,9)
b:+1// List(1, 2, 8, 9, 1)
/:
对数组中所有的元素从左向右遍历,进行相同的迭代操作,foldLeft 的简写
val b=List(1,2,8,9)
(10 /: b) (_ + _) // (((10+1)+2)+8)+9
:\
对数组中所有的元素从右向左遍历,进行相同的迭代操作,foldRight 的简写
val b=List(1,2,8,9)
(b:\10) (_ + _) // 1+(2+(8+(9+10)))
addString()
将数组中的元素逐个添加到 StringBuilder 中
val a=Array(1,2,3,4,5)
val c=new StringBuilder()
a.addString(c)//12345
addString(b, sep)
将数组中的元素逐个添加到 StringBuilder 中,每个元素用 sep 分隔符分开
val a=Array(1,2,3,4,5)
val c=new StringBuilder()
a.addString(c,",")//1,2,3,4,5
aggregate
聚合计算,aggregate 是柯里化方法,参数是两个方法 匿名函数,函数作为参数
def seqno(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
}
def main(args: Array[String]) {
val a = Array(1, 2, 3, 4)
val b = a.aggregate(5)(seqno, combine) // 不分区
println("b = " + b)
/*
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b = 15
*/
val c = a.par.aggregate(5)(seqno, combine) // 分区
println("c = " + c)
/*
* seq_exp = 5 + 3
* seq_exp = 5 + 2
* seq_exp = 5 + 4
* seq_exp = 5 + 1
* com_exp = 6 + 7
* com_exp = 8 + 9
* com_exp = 13 +17
* c = 30
*/
}
//可简写成如下形式
val b = a.aggregate(5)(_+_,_+_) // 不分区
val c = a.par.aggregate(5)(_+_,_+_) // 分区
apply
获取指定索引处的元素" 下标从0开始
val a=Array(1,2,3,4,5)
a.apply(1)//2
canEqual
判断两个对象是否可以进行比较" 基本所有对象都能进行比较
charAt
获取 index 索引处的字符,这个方法会执行一个隐式的转换,将 Array[T] 转换为 ArrayCharSequence,只有当 T 为 Char 类型时,这个转换才会发生 下标从0开始
val d=Array('a','b')
d.charAt(0)//a
clone
创建一个副本 相当于复制,会产生一个新地址
val a=Array(1,2,3,4,5)
a.clone ()//Array(1,2,3,4,5)
collect
通过执行一个并行计算(偏函数),得到一个新的数组对象
val fun: PartialFunction[Char, Char] = {
case 'a' => 'A'
case x => x
}
val d = Array('a', 'b', 'c')
d.collect(fun) // A,b,c
collectFirst
在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
val fun: PartialFunction[Any, Int] = {
case x: Int => x * 100
}
val d= Array(1, 'a', "b",3)
d.collectFirst(fun)//Some(100)
combinations
表示组合,这个排列组合会选出所有包含字符不一样的组合,但不考虑顺序,对于 “abc”、“cba”,视为相同组合,参数 n 表示序列长度,就是几个字符为一组 生成的是个迭代器,只能使用一次
val d = Array("a", "b", "c")
val e= d.combinations(2)
e.foreach(x => println(x.mkString(",")))
/*
a,b
a,c
b,c
*/
contains
判断序列中是否包含指定对象
val a = Array(1,2,3,4)
a.contains(3)//true
containsSlice
判断当前序列中是否包含另一个序列
val a = Array(1,2,3,4)
val s=Array(1,2)
a.containsSlice(s)//true
copyToArray(xs)
将当前数组元素复制到另一个数组中
val a = Array(1,2,3,4,5)
val e: Array[Int] = new Array(10)
a.copyToArray(e)
e.foreach(println)
/*1
2
3
4
5
0
0
0
0
0*/
copyToArray(xs, start)
将当前数组元素复制到另一个数组中,从 start 位置开始复制 数组下标从0开始,start是下标位置
val a = Array(1,2,3,4,5)
val e: Array[Int] = new Array(10)
a.copyToArray(e,4)
e.foreach(println)
/*0
0
0
0
1
2
3
4
5
0*/
copyToArray(xs, start, len)
将当前数组元素复制到另一个数组中,从 start 位置开始复制,长度为 len
val a = Array(1,2,3,4,5)
val e: Array[Int] = new Array(10)
a.copyToArray(e,4)
e.foreach(println)
/*0
0
0
0
1
2
3
0
0
0*/
copyToBuffer
将数组中的元素复制到 Buffer 中
import scala.collection.mutable.ArrayBuffer
val a = Array(1,2,3,4,5)
val e: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(e)
e.foreach(println)
corresponds
判断两个序列的长度以及对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 p(x, y)=true,则返回 true “a.corresponds(b)(_ < _)位置一一对应”
val a = Array(1,2,3,4,5)
val e= Array(1,2,3,4)
val f = Array(1,2,3,4,5)
val g = Array(1,2,3,4,8)
a.corresponds(e)(_==_)//false
a.corresponds(f)(_==_)//true
a.corresponds(g)(_==_)//false
count
统计符合条件的元素个数
val a=Array(1,3,5,7,9)
a.count(x=>x>3) //3
a.count(x=>x>5) //2
a.count(x=>if(x<8&& x>3) true else false) //2
//等同于
a.count(x=>(x>3&&x<8))
diff
计算当前数组与另一个数组的差集,即将当前数组中没有在另一个数组中出现的元素返回
val a=Array(1,2,3,4)
val b=Array(3,4,5,6)
a.diff(b) //1,2
b.diff(a) //5,6
distinct
去除当前集合中重复的元素,只保留一个
val dis=Array(1,2,3,1,3,8,9)
dis.distinct// Array[Int] = Array(1, 2, 3, 8, 9)
drop
去掉当前数组前n个元素的
val a=Array(1,2,3,4)
a.drop(2) //Array(3,4)
dropRight
去掉尾部的 n 个元素
val a=Array(1,2,3,4)
a.dropRight(1)//Array(1,2,3)
dropWhile
去除当前数组中符合条件的元素,返回剩余的数组,这个需要一个条件,就是从当前数组的第一个元素起,就要满足条件,直到碰到第一个不满足条件的元素结束(即使后面还有符合条件的元素),否则返回整个数组
val a=Array(1,2,3,4)
a.dropWhile(x=>x==2)//返回原数组
endsWith
判断当前序列是否以某个序列结尾
val a=Array(1,2,3,4)
val b=Array(3,4)
val c=Array(3,2,4,5)
a.endsWith(b)//true
a.endsWith(c)//false
exists
判断当前数组是否包含符合条件的元素
val a=Array(1,2,3,4)
a.exists(x=>x>4)//false
a.exists(x=>x>3)//true
filter
取得当前数组中符合条件的元素,组成新的数组返回
val a=Array(1,2,3,4)
a.filter(x=>x>2)//Array(3,4)
a.filterNot(x=>x>2)//Array(1,2) 取反
find
查找第一个符合条件的元素,返回 Option
val a=Array(1,2,3,4)
val b=a.find(x=>x>5) //None
val b=a.find(x=>x>3)
b.get //4
flatMap
对当前序列的每个元素进行操作,结果放入新序列返回,参数要求是 GenTraversableOnce 及其子类
val a=Array(1,2,3,4)
a.flatMap(x=>1 to x)
// Array(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)
/*
1
1,2
1,2,3
1,2,3,4
*/
flattten
扁平化将二维数组的所有元素组合在一起,形成一个一维数组返回
val a=Array(Array(1,2),Array(3,4,5))
a.flatten()//Array(1,2,3,4,5)
fold
对序列中的每个元素进行二元运算,和 aggregate 有类似的语义,但执行过程有所不同
val a=Array(1,2,3,4)
a.fold(10)(_+_)
// 20
foldLeft
从左到右计算
val a=Array(1,2,3,4)
a.foldLeft(10)(_+_)
// 20
foldRight
从右到左计算
val a=Array(1,2,3,4)
a.foldRight(10)(_+_)
// 20
forall
判断是不是所有元素都符合条件,返回的是布尔值
val a=Array(1,2,3,4)
a.forall(_>0)//true
foreach
遍历元素
val a=Array(1,2,3,4)
a.foreach(println)
/*1
2
3
4
*/
groupBy
按条件分组,条件由 f 匹配,返回值是 Map 类型,每个 key 对应一个数组
val a=Array(1,2,3,4)
a.groupBy(_<3).toList
/* List[(Boolean, Array[Int])] = List((false,Array(3, 4)),
(true,Array(1, 2)))
*/
grouped
按指定数量分组,每组有 size 个元素,返回一个迭代器
val a=Array(1,2,3,4)
a.grouped(3).toList
/*List[Array[Int]] = List(Array(1, 2, 3),
Array(4))
*/
hasDefiniteSize
检测序列是否存在有限的长度,对应 Stream 这样的流数据则返回 false
val a=Array(1,2,3,4)
a.hasDefiniteSize//true
head
返回序列的第一个元素,如果序列为空,将引发错误
val a=Array(1,2,3,4)
a.head//1
headOption
返回序列的第一个元素的 Option 类型对象,如果序列为空,则返回 None
val a=Array(1,2,3,4)
a.headOption// Some(1)
indexOf(elem)
返回元素 elem 在序列中第一次出现的索引
val a=Array(1,2,3,4)
a.indexOf(2)//1
indexOf(elem,from)
返回元素 elem 在序列中第一次出现的索引,指定从索引 from 开始查找
val a=Array(1,2,3,4)
a.indexOf(2,1)//1
indexOfSlice(that)
检测当前序列中是否包含序列 that,并返回第一次出现该序列的索引
val a=Array(1,2,3,4)
val b=Array(3,4)
a.indexOfSlice(b)//2
indexWhere§
返回当前序列中第一个满足条件 p 的元素的索引
val a=Array(1,2,3,2,3,4)
a.indexWhere(x=>x>2)//2
indexWhere(p, from)
返回当前序列中第一个满足条件 p 的元素的索引,指定从索引 from 开始查找
val a=Array(1,2,3,2,3,4)
a.indexWhere(_>2,4)// 4
a.indexWhere(_>2,0)// 2,下标从0开始
indices
返回当前序列索引集合
val a=Array(1,2,3,2,3,4,5)
val b=a.indices//(0,1,2,3,4,5,6)
init
返回当前序列中不包含最后一个元素的序列
val a=Array(1,2,3,2,3,4,5)
a.init//(1,2,3,2,3,4)
inits
对集合中的元素进行 init 迭代操作,该操作的返回值中, 第一个值是当前序列的副本,最后一个值为空,每一步都进行 init 操作,上一步的结果作为下一步的操作对象
val a=Array(1,2,3,2,3,4,5)
a.inits.foreach(x=>println(x.mkString(",")))
/*1,2,3,2,3,4,5
1,2,3,2,3,4
1,2,3,2,3
1,2,3,2
1,2,3
1,2
1 */
intersect
取两个集合的交集
val a=Array(1,2,3,4)
val b=Array(1,2,5,6)
a.intersect(b)//(1,2)
isDefinedAt
断序列中是否存在指定索引
val a=Array(1,2,3,4)
a.isDefinedAt(1)//true
isEmpty
判断序列是否为空
val a=Array(1,2)
a.isEmpty//false
val b= new Array[Int](0)
b.isEmpty//true
isTraversableAgain
判断序列是否可以反复遍历,该方法是 GenTraversableOnce 中的方法,对于 Traversables 一般返回 true,对于 Iterators 返回 false,除非被复写
val a=Array(1,2,3,4)
a.isTraversableAgain//true
a.iterator.isTraversableAgain//false
iterator
生成当前序列的迭代器
last
返回序列的最后一个元素,如果序列为空,将引发错误
val a=Array(1,2,3,4)
a.last //4
lastIndexOf(elem)
返回元素 elem 在序列中最后一次出现的索引
val a=Array(1,2,3,1,2,3)
a.lastIndexOf(1)//3
lastIndexOf(elem, end)
返回元素 elem 在序列中最后一次出现的索引,指定在索引 end 之前(包括)的元素中查找
lastIndexOfSlice(that)
检测当前序列中是否包含序列 that,并返回最后一次出现该序列的索引
lastIndexOfSlice(that, end)
检测当前序列中是否包含序列 that,并返回最后一次出现该序列的索引,指定在索引 end 之前(包括)的元素中查找
lastIndexWhere§
返回当前序列中最后一个满足条件 p 的元素的索引
lastIndexWhere(p, end)
返回当前序列中最后一个满足条件 p 的元素的索引,指定在索引 end 之前(包括)的元素中查找
lastOption
返回序列的最后一个元素的 Option 类型对象,如果序列为空,则返回 None
length
返回序列元素个数
val a=Array(1,2,3,1,2,3)
a.length//6
lengthCompare
比较序列的长度和参数 len,返回序列的长度 - len
val a=Array(1,2,3,1,2,3)
a.lengthCompare(10)//-4
map
对序列中的元素进行 f 操作,返回生成的新序列
val a = Array(1, 2, 3, 4)
a.map(x => x * 10) // Array(10,20,30,40)
a.map(x=>(x,10))
//Array[(Int, Int)] = Array((1,10), (2,10), (3,10), (2,10), (3,10), (4,10))
max
返回序列中最大的元素
val a=Array(1,2,3,4,5)
a.max//5
maxBy
返回序列中符合条件的第一个元素
val a=Array(1,2,3,4,5)
a.maxBy(x=>x>3)//4
//如果没有符合条件的,会返回第一个元素
min
val a=Array(1,2,3,4)
a.min//1
minBy
返回序列中不符合条件的第一个元素
val a=Array(1,2,3,4,5)
a.mixBy(x=>x>3)//1
mkString
将序列中所有元素拼接成一个字符串
val a = Array(1, 2, 3, 4)
a.mkString // 1234
mkString(sep)
将序列中所有元素拼接成一个字符串,以 sep 作为元素间的分隔符
val a = Array(1, 2, 3, 4)
a.mkString(",") // 1,2,3,4
mkString(start, sep, end)
将序列中所有元素拼接成一个字符串,以 start 开头,以 sep 作为元素间的分隔符,以 end 结尾
val a = Array(1, 2, 3, 4)
a.mkString("(", ",", ")") // (1,2,3,4)
nonEmpty
判断序列是否不为空
val a = Array(1, 2, 3, 4)
a.nonEmpty //true
padTo
填充序列,如果当前序列长度小于 len,那么新产生的序列长度是 len,多出的几个位值填充 elem,如果当前序列大于等于 len ,则返回当前序列
val a=Array(1,2,3,4,5)
a.padTo(10,6)//Array(1,2,3,4,5,6,6,6,6,6,)
a.padTo(3,6)//Array(1,2,3,4,5)
par
返回一个并行实现,产生的并行序列不能被修改
partition
按条件将序列拆分成两个数组,满足条件的放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组
val a=Array(1,2,3,4,5)
a.partition(x => x % 2 == 0)
// (Array[Int], Array[Int]) = (Array(2, 4),Array(1, 3, 5))
patch
def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
批量替换,从原序列的 from 处开始,后面的 replaced 个元素,将被替换成序列 that
val a = Array(1, 2, 3, 4)
val b = Array(7, 8, 9)
a.patch(1, b, 2) // Array(1,7,8,9,4)
a.patch(1, b, 1) // Array(1,7,8,9,3,4)
permutations
permutations 表示排列,这个排列组合会选出所有排列顺序不同的字符组合,permutations 与 combinations 不同的是,相同的组合考虑排列,对于 “abc”、“cba”,视为不同的组合
val a = Array(1, 2, 3, 4)
a.permutations.toList
//a.permutations 生成的是个迭代器
/* List[Array[Int]] = List(Array(1, 2, 3, 4), Array(1, 2, 4, 3),
Array(1, 3, 2, 4), Array(1, 3, 4, 2),
Array(1, 4, 2, 3), Array(1, 4, 3, 2),
Array(2, 1, 3, 4), Array(2, 1, 4, 3),
Array(2, 3, 1, 4), Array(2, 3, 4, 1),
Array(2, 4, 1, 3), Array(2, 4, 3, 1),
Array(3, 1, 2, 4), Array(3, 1, 4, 2),
Array(3, 2, 1, 4), Array(3, 2, 4, 1),
Array(3, 4, 1, 2), Array(3, 4, 2, 1),
Array(4, 1, 2, 3), Array(4, 1, 3, 2),
Array(4, 2, 1, 3), Array(4, 2, 3, 1),
Array(4, 3, 1, 2), Array(4, 3, 2, 1))*/
prefixLength
给定一个条件 p,返回一个前置数列的长度,这个数列中的元素都满足 p
有点类似加了条件的count
product
返回所有元素乘积的值
val a = Array(1, 2, 3, 4)
a.product//24
reduce
同 fold,不需要初始值
val a = Array(1, 2, 3, 4)
a.reduce(_+_)//10
reduceLeft
同 foldLeft,从左向右计算,不需要初始值
val a = Array(1, 2, 3, 4)
a.reduceLeft(_+_)//10
reduceRight
同 foldRight,从右向左计算,不需要初始值
val a = Array(1, 2, 3, 4)
a.reduceRight(_+_)//10
reduceLeftOption
同 reduceLeft,返回 Option
val a = Array(1, 2, 3, 4)
a.reduceLeftOption(_+_)//Some(10)
reduceRightOption
同 reduceRight,返回 Option
val a = Array(1, 2, 3, 4)
a.reduceRightOption(_+_)//Some(10)
reverse
反转序列
val a = Array(1, 2, 3, 4)
a.reverse// Array(4, 3, 2, 1)
reverseIterator
生成反向迭代器
val a = Array(1, 2, 3, 4)
a.reverseIterator.toList
//List[Int] = List(4, 3, 2, 1)
reverseMap
同 map,方向相反
val a = Array(1, 2, 3, 4)
a.reverseMap(_*10)
//Array[Int] = Array(40, 30, 20, 10)
sameElements
判断两个序列是否顺序和对应位置上的元素都一样
val a = Array(1, 2, 3, 4)
val b = Array(1, 2, 3, 4)
val c = Array(1, 3, 2, 4)
a.sameElements(b) // true
a.sameElements(c) // false
scan
同 fold,scan 会把每一步的计算结果放到一个新的集合中返回,而 fold 返回的是最后的结果
需要初始值
val a = Array(1, 2, 3, 4)
a.scan(0)(_+_)
// Array[Int] = Array(0, 1, 3, 6, 10)
scanLeft
同 foldLeft,从左向右计算,每一步的计算结果放到一个新的集合中返回
val a = Array(1, 2, 3, 4)
a.scanLeft(0)(_+_)
// Array[Int] = Array(0, 1, 3, 6, 10)
scanRight
同 foldRight,从右向左计算,每一步的计算结果放到(从右向左放)一个新的集合中返回
val a = Array(1, 2, 3, 4)
a.scanRight(0)(_+_)
// Array[Int] = Array(10, 9, 7, 4, 0)
segmentLength
从序列的 from 开始向后查找,返回满足条件 p 的连续元素的长度,只返回第一个,需要第一个就满足条件,不满足会直接返回0
val a = Array(1, 2, 3, 3, 2, 1, 4,5,6,7)
a.segmentLength(x => x>2, 1)
seq
产生一个引用当前序列的 sequential 视图
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.seq//scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
size
返回序列元素个数,同 length
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.size//11
slice
返回当前序列中从 from 到 until 之间的序列,不包括 until 处的元素
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.slice(2,5)//Array(8, 7, 1),2和5是数组下标
sliding(size)
滑动,从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组,最终组成一个新的集合返回,当剩余元素个数不够 size 时,则结束
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sliding(5).toList
/*List[Array[Int]] = List(Array(1, 9, 8, 7, 1), Array(9, 8, 7, 1, 2),
Array(8, 7, 1, 2, 3), Array(7, 1, 2, 3, 6),
Array(1, 2, 3, 6, 7), Array(2, 3, 6, 7, 8),
Array(3, 6, 7, 8, 9))*/
sliding(size, step)
从第一个元素开始,每个元素和它后面的 size - 1 个元素组成一个数组,最终组成一个新的集合返回,当剩余元素个数不够 size 时,则结束。该方法可以设置步长 step,每一组元素组合完后,下一组从上一组起始元素位置 + step 后的位置处开始
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sliding(5,4).toList
/*List[Array[Int]] = List(Array(1, 9, 8, 7, 1),
Array(1, 2, 3, 6, 7),
Array(7, 8, 9))*/
sortBy/sortWith/sorted
sorted 使用默认的排序规则对序列排序
按指定的排序规则对序列排序
sortWith可以指定排序方式
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sortBy(x=>x)// 按 x 从小到大,即对原序列升序排列
// Array[Int] = Array(1, 1, 2, 3, 6, 7, 7, 8, 8, 9, 9)
a.sortBy(x=>0-x)//按 -x 从小到大,即对原序列降序排列
//Array[Int] = Array(9, 9, 8, 8, 7, 7, 6, 3, 2, 1, 1)
a.sortWith(_>_)
//Array[Int] = Array(9, 9, 8, 8, 7, 7, 6, 3, 2, 1, 1)
a.sorted
//Array[Int] = Array(1, 1, 2, 3, 6, 7, 7, 8, 8, 9, 9)
span
将序列拆分成两个数组,从第一个元素开始,直到第一个不满足条件的元素为止,其中的元素放到第一个数组,其余的放到第二个数组,返回的是包含这两个数组的元组
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.span(x => x < 3)
/* (Array[Int], Array[Int]) = (Array(1),Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9))*/
splitAt
从指定位置开始,把序列拆分成两个数组
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.splitAt(2)
/* (Array[Int], Array[Int]) = (Array(1, 9),Array(8, 7, 1, 2, 3, 6, 7, 8, 9))*/
startsWith(that)
判断序列是否以某个序列开始
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val t=Array(9)
a.startsWith(b)//false
startsWith(that, offset)
判断序列从指定偏移处是否以某个序列开始
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val t=Array(9)
a.startsWith(t,1)//true
stringPrefix
返回 toString 结果的前缀
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.toString//[I@40ccda8b
a.stringPrefix//[I
subSequence(start,end)
返回 start 和 end 间的字符序列,不包含 end 处的元素
val d=Array('a','b','c','d','e','f')
d.subSequence(1,3)// CharSequence = bc
//是char类型
sum
序列求和,元素需为 Numeric[T] 类型
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.sum//61
tail
返回当前序列中不包含第一个元素的序列
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.tail//Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
tails
同 inits,每一步都进行 tail 操作
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.tails
/* List[Array[Int]] = List(Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9),
Array(9, 8, 7, 1, 2, 3, 6, 7, 8, 9),
Array(8, 7, 1, 2, 3, 6, 7, 8, 9),
Array(7, 1, 2, 3, 6, 7, 8, 9),
Array(1, 2, 3, 6, 7, 8, 9),
Array(2, 3, 6, 7, 8, 9),
Array(3, 6, 7, 8, 9),
Array(6, 7, 8, 9),
Array(7, 8, 9),
Array(8, 9), A
rray(9),
Array())
*/
take
返回当前序列中,前 n 个元素组成的序列
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.take(5)//Array[Int] = Array(1, 9, 8, 7, 1)
takeRight
返回当前序列中,从右边开始,后 n 个元素组成的序列
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.takeRight(5)/ Array[Int] = Array(3, 6, 7, 8, 9)
takeWhile
返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.takeWhile(_<5)//Array[Int] = Array(1)
toArray
将序列转换成 Array 类型
toBuffer
将序列转换成 Buffer 类型
toIndexedSeq
将序列转换成 IndexedSeq 类型
toIterable
将序列转换成可迭代的类型
toIterator
将序列转换成迭代器,同 iterator 方法
toList
将序列转换成 List 类型
toMap
将序列转转换成 Map 类型,需要被转化序列中包含的元素是 Tuple2 类型
val z= Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
z.flatten.map(x=>(x,1)).toMap
//cala.collection.immutable.Map[String,Int] = Map(e -> 1, f -> 1, a -> 1, b -> 1, c -> 1, d -> 1)
toSeq
将序列转换成 Seq 类型
toSet
将序列转换成 Set 类型
toStream
将序列转换成 Stream 类型
toVector
将序列转换成 Vector 类型
transpose
矩阵转置,二维数组行列转换
val z= Array(Array("a", "b"), Array("c", "d"), Array("e", "f"))
z.transpose.toList
//List[Array[String]] = List(Array(a, c, e), Array(b, d, f))
union
合并两个序列,同操作符 ++
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
val b= Array(7, 8, 9)
a.union(b)
// Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9, 7, 8, 9)
b.union(a)
//Array(7, 8, 9, 1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
unzip
将含有两个二元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,返回包含这两个数组的元组
val z= Array(("a", "b"),("c", "d"),("e", "f"))
z.unzip// (Array[String], Array[String]) = (Array(a, c, e),Array(b, d, f))
unzip3
将含有三个三元组的数组,每个元组的第一个元素组成一个数组,第二个元素组成一个数组,第三个元素组成一个数组,返回包含这三个数组的元组
val z= Array((1,2,3),(4,5,6),(7,8,9))
z.unzip3// (Array[Int], Array[Int], Array[Int]) = (Array(1, 4, 7),Array(2, 5, 8),Array(3, 6, 9))
update
将序列中 i 索引处的元素更新为 x
val a = Array(1, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.update(0,10)// a=Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9),更新后不会输出更新后的结果,需要自己查看,更新的是原数组的数据
updated
将序列中 i 索引处的元素更新为 x,并返回替换后的数组
val a = Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.updated(10,11)// Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 11),更新后会返回结果,但是原数组不变
view
返回当前序列中从 from 到 until 之间的序列,不包括 until 处的元素
val a = Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.view(0,3).toList// List[Int] = List(10, 9, 8),没有toList返回的是个序列,不会输出结果
withFilter
根据条件 p 过滤元素
val a = Array(10, 9, 8, 7, 1, 2, 3, 6, 7, 8, 9)
a.withFilter(_<5).map(x=>x)
//Array[Int] = Array(1, 2, 3)
zip
将两个序列对应位置上的元素组成一个元组数组
val b = Array(7,8,9)
val f = Array(4,5,6)
b.zip(f)
// Array((7,4), (8,5), (9,6))
f.zip(b)
//Array((4,7), (5,8), (6,9))
zipAll
def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
同 zip ,但是允许两个序列长度不同,不足的自动填充,如果当前序列短,不足的元素填充为 thisElem,如果 that 序列短,填充为 thatElem
val b = Array(7,8,9,10,11)
val f = Array(4,5,6)
b.zipAll(f,10,66)
//Array[(Int, Int)] = Array((7,4), (8,5), (9,6), (10,66), (11,66))
f.zipAll(b,10,66)
//Array[(Int, Int)] = Array((4,7), (5,8), (6,9), (10,10), (10,11))
zipWithIndex 序列中的每个元素和它的索引组成一个元组数组
val b = Array(7,8,9,10,11)
b.zipWithIndex
//Array[(Int, Int)] = Array((7,0), (8,1), (9,2), (10,3), (11,4))