前言：
1.下文中a1、a2、a3，均由下方代码定义。
var a1 = Array.range(1,10) Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
var a2 = Array("a","b","c","d") Array[String] = Array(a, b, c, d)
var a3 = Array(3,5,4,1,2) Array[Int] = Array(3, 5, 4, 1, 2)
2.下文中的蓝色字体均可点击
（在网页端，“向上”的锚点有可能会失效，但是在手机端就可以上下随意跳跃，我也不知道为什么，若是介意部分锚点失效的朋友，可移步至手机端）
按字母顺序分类
[ A、C、D、E、F、G、H、I、L、M、N、P、R、S、T、U、V、W、Z ]
| A | ||
|---|---|---|
| addString | aggregate | andThen |
| apply | applyOrElse | apply |
| C | |||
|---|---|---|---|
| canEqual | charAt | clone | collect |
| collectFirst | combinations | compose | contains |
| containsSlice | copyToArray | copyToBuffer | corresponds |
| count |
| D | ||
|---|---|---|
| diff | distinct | drop |
| dropRight | dropWhile |
| E | |
|---|---|
| endsWith | exists |
| F | ||||
|---|---|---|---|---|
| filter | filterNot | find | flatMap | flatten |
| fold | foldLeft | foldRight | forall | foreach |
| G | |
|---|---|
| groupBy | grouped |
| H | ||
|---|---|---|
| hasDefiniteSize | head | headOption |
| I | |||
|---|---|---|---|
| indexOf | indexOfSlice | indexWhere | indices |
| init | inits | intersect | isDefinedAt |
| isEmpty | isTraversableAgain | iterator |
| L | |||
|---|---|---|---|
| last | lastOption | lastIndexOf | lastIndexOfSlice |
| lastIndexWhere | length | lengthCompare |
| M | ||
|---|---|---|
| map | max | maxBy |
| min | minBy | mkString |
| N |
|---|
| nonEmpty |
| P | |||
|---|---|---|---|
| par | padTo | partition | patch |
| permutations | prefixLength | product |
| R | ||||
|---|---|---|---|---|
| reduce | reduceLeft | reduceRight | reduceOption | reduceLeftOption |
| reduceRightOption | reverse | reverseIterator | reverseMap | runWith |
| S | ||||
|---|---|---|---|---|
| sameElements | scan | scanLeft | scanRight | segmentLength |
| seq | size | slice | sliding | sortBy |
| sorted | sortWith | span | splitAt | stringPrefix |
| subSequence | sum | startsWith |
| T | |||
|---|---|---|---|
| take | takeRight | takeWhile | tail |
| tails | toXxx | transform | transpose |
| U | ||
|---|---|---|
| union | unzip | unzip3 |
| update | updated |
| V |
|---|
| view |
| W |
|---|
| withFilter |
| Z | ||
|---|---|---|
| zip | zipAll | zipWithIndex |
按使用方法分类
[ 元素操作、元素取头尾、数组中的计算、字符串相关操作、方法操作、指定条件判断、下标索引操作、数组拆分排序、数组长度、两数组操作、数组克隆和复制、数组反转、数组的行列操作、类型转换 ]
| 元素操作 | |||
|---|---|---|---|
| combinations | distinct | drop | dropRight |
| dropWhile | max | maxBy | min |
| minBy | padTo | patch | permutations |
| prefixLength | transform | update | updated |
| 元素取头尾 | |||
|---|---|---|---|
| head | headOption | last | lastOption |
| init | inits | tail | tails |
| take | takeRight | takeWhile |
| 数组中的计算 | ||||
|---|---|---|---|---|
| fold | foldLeft | foldRight | product | reduce |
| reduceLeft | reduceRight | reduceOption | reduceLeftOption | reduceRightOption |
| scan | scanLeft | scanRight | sum |
| 字符串相关操作 | ||
|---|---|---|
| addString | mkString | stringPrefix |
| 方法操作 | ||||
|---|---|---|---|---|
| aggregate | andThen | applyOrElse | compose | collect |
| collectFirst | foreach | iterator | map | runWith |
| 指定条件判断 | |||
|---|---|---|---|
| contains | containsSlice | count | endsWith |
| exists | filter | filterNot | find |
| forall | hasDefiniteSize | isDefinedAt | isEmpty |
| isTraversableAgain | nonEmpty | startsWith | withFilter |
| 下标索引操作 | |||
|---|---|---|---|
| apply | charAt | indexOf | indexOfSlice |
| indexWhere | indices | lastIndexOf | lastIndexOfSlice |
| lastIndexWhere | slice | subSequence | view |
| 数组拆分排序 | ||||
|---|---|---|---|---|
| groupBy | grouped | par | partition | span |
| sliding | splitAt | sortBy | sorted | sortWith |
| 数组长度 | |
|---|---|
| length | lengthCompare |
| segmentLength | size |
| 两数组操作 | ||
|---|---|---|
| canEqual | corresponds | diff |
| intersect | sameElements | union |
| 数组克隆和复制 | |
|---|---|
| clone | copyToArray |
| copyToBuffer | seq |
| 数组反转 | ||
|---|---|---|
| reverse | reverseIterator | reverseMap |
| 数组的行列操作 | |||
|---|---|---|---|
| flatMap | flatten | transpose | unzip |
| unzip3 | zip | zipAll | zipWithIndex |
| 类型转换 |
|---|
| toXxx |
addString
将数组中的元素逐个添加到StringBuilder中，每个元素用指定分隔符分开
import scala.collection.mutable.StringBuilder
var builder = new mutable.StringBuilder
a1.addString(builder)
println(builder) >123456789
a1.addString(builder,",")
println(builder) >1, 2, 3, 4, 5, 6, 7, 8, 9
a1.addString(builder,"[",",","]")
println(builder) >[1, 2, 3, 4, 5, 6, 7, 8, 9]
aggregate
将原来接受两个参数的函数变成新的接受一个参数的函数的过程。
新的函数返回一个以原有第二个参数为参数的函数方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(10))
}
println(lst.par) >ParArray(9, 0, 2, 5, 7)
println(lst.par.aggregate(0)(add, add)) > 0+9=9
0+5=5
#其中的”0“是初始值，初始值可以任意设置 0+2=2
0+7=7
0+0=0
5+7=12
9+0=9
2+12=14
9+14=23
23
andThen
# def f = f1 andThen f2
# f1 与 f2 只有【一个参数】，且类型相同，f1 的输出为 f2 的输入，先调用 f1，再调用 f2
val add = (x:Int)=>{
var z=x+7
println(s"$x + 7 =$z")
z
}
val minus = (x:Int)=>{
var z=x-3
println(s"$x - 3 =$z")
z
}
def am = add andThen minus
println(am(3)) > 3 + 7 =10
10 - 3 =7
7
# 偏函数
a1.andThen(x=>{}) => PartitionFunction[Int,c]
a1.andThen(x=>{if(x%2==0) x})(0) => 如果下标0位偶数输出该数，否则就输出Unit:()
#1
val pf:PartialFunction[Int,Boolean] = (x:Int) => {
x match {
case x if x%2==0 => true
}
}
println(pf(1)) > MatchError: 1 (of class java.lang.Integer)
println(pf(2)) > true
#2
val pf:PartialFunction[Int,Boolean] = (x:Int) => {
x match {
case x if x%2==0 => true
case x => false
}
}
println(pf(1)) > false
println(pf(2)) > true
#3可选类型
val pf:PartialFunction[Int,Option[String]] = (x:Int) => {
x match {
case x if x%3==0 => Some("three")
case x if x%7==0 => Some("seven")
case x => None
}
}
println(pf(5)) > None
println(pf(6)) > Some("three")
#4 Some 如果Some中也是引用类型，那就继续剥下去
var op = Some("three")
println(op) > Some("three")
println(op.get) > three
var op = Some("three","abc","def")
op.get.productIterator.foreach(println) > three
abc
def
var op = Some(Array("three","abc","def"))
op.get.foreach(println) > three
abc
def
var op = Some("three","abc","def")
op.get._1.foreach(print) > three
op.get._1.foreach(println) > t
h
r
e
e
applyOrElse
根据下标取数组元素，如果越界，则返回默认值
a1.applyOrElse(0,{i:Int=>"None"}) >Any = 1
a1.applyOrElse(11,{i:Int=>"None"}) >Any = None
apply
根据索引选取元素
a1.apply(1) >2
a1.(1) >2
canEqual
两个集合之间是否可以比较，基本上都可以比较
a1.canEqual(a2) >Boolean = true
charAt(index)
根据索引取字符，只能用于字符串数组
var arr = Array('a','b','c')
arr.charAt(0) > Char = a
clone
【浅克隆】
克隆一个数组的副本，若数组的类型位AnyRef，则副本中存储的是对象的引用
collect
返回所有与参数匹配的值
# a1.collect[First](PartitionFunction)
var arr = Array(41,56,1,8,56,2,78,32)
arr.collect({case i if(i%3==0)=>i}).foreach(println) >78
a1.collect({case i if(i%3==0)=>i}) >Array[Int] = Array(3, 6, 9)
collectFirst
返回第一个与参数匹配的值
a1.collectFirst({case i if(i%3==0)=>i}) >Array[Int] = Some(3)
combinations
排列组合，不考虑顺序
#n任意选择集合中n个元素进行组合
a3.combinations(3).toArray
>Array[Array[Int]] = Array(Array(3, 5, 4), Array(3, 5, 1), Array(3, 5, 2), Array(3, 4, 1), Array(3, 4, 2), Array(3, 1, 2), Array(5, 4, 1), Array(5, 4, 2), Array(5, 1, 2), Array(4, 1, 2))
compose
# def f = f1 andThen f2
# f1 与 f2 只有【一个参数】，且类型相同，f1 的输出为 f2 的输入，先调用 f2，再调用 f1
val add = (x:Int)=>{
var z=x+7
println(s"$x + 7 =$z")
z
}
val minus = (x:Int)=>{
var z=x-3
println(s"$x - 3 =$z")
z
}
def am = add compose minus
println(am(3)) > 3 - 3 =0
0 + 7 =7
7
contains
集合中是否包含指定元素
a1.contains(20) >Boolean = false
containsSlice(GenSeq)
序列中是否包含子序列
#子序列必须【有序的】、【连续的】出现才会返回true
a1.containsSlice(a3) >Boolean = false
copyToArray ([Array,startPos[,len]])
讲集合中的元素从0开始，拷贝到参数1数组从startPos开始，长度位len的数组中
var lst = new ArrayBuffer[Int]
for(elem <- 1 to 5){
lst.append(Random.nextInt(10))
}
var arr = Array(0,0,0,0)
lst.foreach(x=>print(s"$x,")) > 6,3,1,5,9,
lst.copyToArray(arr)
arr.foreach(println) > 6
3
1
5
lst.foreach(x=>print(s"$x,")) > 5,6,2,7,7,
lst.copyToArray(arr,2)
arr.foreach(println) > 0
0
5
6
lst.foreach(x=>print(s"$x,")) > 1,7,0,0,8,
lst.copyToArray(arr,2,2)
arr.foreach(println) > 0
0
1
7
copyToBuffer(Buffer)
将集合中所有的元素拷贝至参数Buffer中
var buff = new ArrayBuffer[Int]
println(buff.size) > 0
a3.copyToBuffer(buff)
println(buff) > 3
5
4
1
2
println(buff.size) > 5
corresponds
q1.corresponds(q2)((x,y)=>Boolean)
q1和q2的长度相等，且a1和a2同一个位置的元素必须符合条件
var q1 = a1.clone
a1.corresponds(q1)(_==_) > Boolean = true
count
统计符合条件的元素数量
a1.count(_%2==0) > Int = 4
diff
返回集合之间的差集
a1.diff(a3) > Array[Int] = Array(6, 7, 8, 9)
distinct
集合去重
var q1 = Array(1,1,2,5,6,8,8)
q1.distinct > Array[Int] = Array(1, 2, 5, 6, 8)
drop
删除操作：不改变源数组，生成新数组
删除数组左侧的n个元素
a1.drop(2) > Array[Int] = Array(3, 4, 5, 6, 7, 8, 9)
dropRight
删除操作：不改变源数组，生成新数组
删除数组右侧的n个元素
a1.dropRight(2) > Array[Int] = Array(1, 2, 3, 4, 5, 6, 7)
dropWhile(p:Type=>Boolean)
删除操作：不改变源数组，生成新数组
删除数组中符合条件的元素
#若第一个元素就不符合条件，就不再看后面的元素了
#从第一个符合条件的元素开始删除，到第一个不符合条件的结束
a1.dropWhile(x=>x<=1) > Array[Int] = Array(2, 3, 4, 5, 6, 7, 8, 9)
endsWith
当前序列是否以参数序列结尾
a1.endsWith(Array(7,8,9)) > Boolean = true
exists
判断当前数组是否包含符合条件的元素
println(a1.exists(_ > 3)) > Boolean = true
filter(p:Type=>Boolean)
保留满足条件的元素
a1.filter(_%2==0) > Array[Int] = Array(2, 4, 6, 8)
filterNot(p:Type=>Boolean)
移除满足条件的元素
a1.filterNot(_%2==0) > Array[Int] = Array(1, 3, 5, 7, 9)
find(p:Type=>Boolean)
查找第一个满足条件的元素
a1.find(_%2==0) > Option[Int] = Some(2)
flatMap(x=>exp) <=> map(x=>exp) + flatten
先map后降维，对当前序列的每个元素进行操作
map之后的每个元素必须还是集合，结果放入新序列返回
val q1 = Array(Array(1,3,5),Array(2,4,6))
q1.flatMap(x=>x.map(x=>(x,1))).foreach(x=>print(x+"\t")) > (1,1) (3,1) (5,1) (2,1) (4,1) (6,1)
q1.flatMap(x=>x.map(x=>(if(x%2==0) "even" else "odd",1))).foreach(x=>print(x+"\t")) > (odd,1) (odd,1) (odd,1) (even,1)(even,1)(even,1)
flatten
扁平化(降维)，将二维数组的所有元素组合在一起，形成一个一维数组返回
val q1 = Array(Array(1,3,5),Array(2,4,6))
q1.flatten.foreach(x => print(x + "\t")) > 1 3 5 2 4 6
fold(initValue)((x,y)=>TYPE)
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
var q1 = Array(12,56,84,13)
q1.par.fold(0)(add) > 0+13=13
0+12=12
0+84=84
0+56=56
84+13=97
12+56=68
68+97=165
foldLeft(initValue)((x,y)=>TYPE)
q1.par.foldLeft(0)(add) > 0+12=12
12+56=68
68+84=152
152+13=165
foldRight(initValue)((x,y)=>TYPE)
q1.par.foldRight(0)(add) > 13+0=13
84+13=97
56+97=153
12+153=165
forall(p:Type=>Boolean)
println(a1.forall(_.isInstanceOf[Int])) > true
println(a1.forall(_%2==0)) > false
foreach(p:Type=>U):Unit
遍历主要输出
a1.foreach(println) > 1
2
3
4
5
6
7
8
9
groupBy(x:T=>K)=>Map
指定K分组
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println(a1.groupBy(x=>x match{
case i if i%2 == 0 => "even"
case i => "odd"
}).map(x=>(x._1,x._2.par.fold(0)(add)))) > 0+5=5
0+1=1
0+7=7
0+3=3
0+9=9
1+3=4
7+9=16
5+16=21
4+21=25
0+6=6
0+8=8
0+4=4
0+2=2
6+8=14
2+4=6
6+14=20
Map(odd -> 25, even -> 20)
grouped(n)
分参数指定数量的n组
a1.grouped(3).foreach(x=>{x.foreach(x=>print(s"$x \t"));println()})
> 1 2 3
4 5 6
7 8 9
hasDefiniteSize
判断Array、List...等，是否有固定长度
a1.hasDefiniteSize > true
a1.toStream.hasDefiniteSize > false
head
返回序列的第一个元素，如果序列可为空，将引发错误
var q1:Array[Int] = Array()
q1.head > next on empty iterator
a1.head > Int = 1
headOption
返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
var q1:Array[Int] = Array()
q1.head > Option[Int] = None
a1.headOption > Option[Int] = Some(1)
indexOf(E[,fromIndex])
返回元素在集合中的索引
a1.indexOf(3) > Int = 2
indexOfSlice
返回集合中子序列的索引
a1.indexOfSlice(Array(1,2)) > Int = 0
a1.indexOfSlice(Array(5,6)) > Int = 4
a1.indexOfSlice(Array(2,1)) > Int = -1
indexWhere(p:B=>Boolean)
返回第一个满足条件的元素下标，若是没有则返回-1
a1.indexWhere(_%2==0) > Int = 1
a1.indexWhere(_%56==0) > Int = -1
indices
返回当前集合的索引集合
a1.indices > scala.collection.immutable.Range = Range 0 until 9
init
返回当前序列中不包含最后一个元素的序列
a1.init.foreach(x=>print(x+"\t"));println() > 1 2 3 4 5 6 7 8
inits
对当前集合进行init迭代
a3.inits.foreach(x=>{x.foreach(y=>print(s"$y,"));println()}) > 3,5,4,1,2,
3,5,4,1,
3,5,4,
3,5,
3,
_,
intersect
返回集合之间的交集
a1.intersect(a3) > Array[Int] = Array(1, 2, 3, 4, 5)
isDefinedAt(index)
是否包含索引
a1.isDefinedAt(4) > Boolean = true
isEmpty
判断是否为空
var q1:Array[Int] = Array()
q1.isEmpty > Boolean = true
a1.isEmpty > Boolean = false
isTraversableAgain
判断是否可以重复遍历
a1.isTraversableAgain > Boolean = true
iterator
获取集合的迭代器
var map = Map("aaa"->19,"bbb"->20,"ccc"->21)
> scala.collection.mutable.Map[String,Int] = Map(ccc -> 21, bbb -> 20, aaa -> 19)
#map迭代时转化为元组
map.foreach(x=>println(s"${x._1}\t${x._2}")) > ccc 21
bbb 20
aaa 19
last
返回序列的最后一个元素，如果序列为空，将引发错误
lastOption
返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
a1.lastOption > Some(9)
lastIndexOf
返回元素 elem 在序列中最后一次出现的索引【，指定在索引 end 之前（包括）的元素中查找】
a1.lastIndexOf(1,2) > 0
a1.lastIndexOf(5) > 4
lastIndexOfSlice(GenSeq[,endIndex])
返回子序列在集合中最后一次出现位置
a1.lastIndexOfSlice(Array(5,6)) > Int = 4
lastIndexWhere(p:B=>Boolean)
返回会最后一个满足条件的元素的下标
a1.lastIndexWhere(_%2==0) > Int = 7
length
返回序列中元素的个数
a1.length > Int = 9
lengthCompare
返回实际元素数量和参数的差值
a1.lengthCompare(12) > Int = -3
map
对序列中的元素进行 f 操作，返回生成的新序列，对一个维度的数据进行操作
val arr = Array(("1001", "henry", "male", 100), ("1002", "pola", "female", 130), ("1003", "ariel", "female", 200))
arr.map(x=>(x._3,x._4)).foreach(x=>print(x+"\t")) > (male,100) (female,130) (female,200)
max
最大值
a1.max > Int = 9
maxBy
返回满足条件的最小值
a1.maxBy(_%2==0) > Int = 2
min
最小值
a1.min > Int = 1
minBy
返回不满足条件的最小值
a1.minBy(_%2==0) > Int = 1
mkString
将数组中的元素用指定分隔符分开
a1.mkString > String = 123456789
a1.mkString(",") > String = 1,2,3,4,5,6,7,8,9
a1.mkString("[",",","]") > String = [1, 2, 3, 4, 5, 6, 7, 8, 9]
nonEmpty
判断是否不为空
var q1:Array[Int] = Array()
q1.nonEmpty > Boolean = false
a1.nonEmpty > Boolean = true
par
返回一个并行序列ParArray[T],内容不可以更改，相当于hashcode partitioner，便于多线程执行
var lst = new ArrayBuffer[Int]
for (elem <- 1 to 5) {
lst.append(Random.nextInt(10))
}
println(lst.par) >ParArray(9, 0, 2, 5, 7)
padTo
填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
a1.padTo(10,"-").foreach(x=>print(x+"\t"))
> 1 2 3 4 5 6 7 8 9 -
partition
将序列拆成满足和不满足条件两个序列xxxBuffer
a1.partition(_>5)._2.foreach(x=>print(x+"\t")) > 1 2 3 4 5
a1.partition(_>5)._1.foreach(x=>print(x+"\t")) > 6 7 8 9
patch(startIndex,GenSeq,num)
批量替换
a1.patch(2,a2,2) > Array[Any] = Array(1, 2, a, b, c, d, 5, 6, 7, 8, 9)
第一个2，代表起始位置的下标
a2，代表将要用于替换操作的元素
第二个2，代表自起始位置起，需要被替换的个数
permutations
所有元素不同顺序的排列
a2.permutations.toArray
>Array[Array[String]] = Array(Array(a, b, c, d), Array(a, b, d, c), Array(a, c, b, d)
, Array(a, c, d, b), Array(a, d, b, c), Array(a, d, c, b), Array(b, a, c, d), Array(b, a, d, c)
, Array(b, c, a, d), Array(b, c, d, a), Array(b, d, a, c), Array(b, d, c, a), Array(c, a, b, d)
, Array(c, a, d, b), Array(c, b, a, d), Array(c, b, d, a), Array(c, d, a, b), Array(c, d, b, a)
, Array(d, a, b, c), Array(d, a, c, b), Array(d, b, a, c), Array(d, b, c, a), Array(d, c, a, b), Array(d, c, b, a))
prefixLength
返回序列中满足条件的元素数量
#如果第一个不满足就返回0
#到第一个不满足条件的元素为止
var q1 = Array(25,76,78,52,46)
q1.prefixLength(_<86) > Int = 5
product
返回序列中所有元素的乘积
a1.product > Int = 362880
reduce
对序列中的每个元素进行二元运算，不需要初始值，其他的和fold一样
var a1 = Array.range(1,10)
a1.reduce((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 1+2=3
3+3=6
6+4=10
10+5=15
15+6=21
21+7=28
28+8=36
36+9=45
Int = 45
reduceLeft
同 foldLeft，从左向右计算，不需要初始值
var a1 = Array.range(1,10)
a1.reduceLeft((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 1+2=3
3+3=6
6+4=10
10+5=15
15+6=21
21+7=28
28+8=36
36+9=45
Int = 45
reduceRight
同 foldLeft，从右向左计算，不需要初始值
var a1 = Array.range(1,10)
a1.reduceRight((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 8+9=17
7+17=24
6+24=30
5+30=35
4+35=39
3+39=42
2+42=44
1+44=45
Int = 45
reduceOption
同 reduceLeftOption，计算Option，返回 Option
var a1 = Array.range(1,10)
a1.reduceOption((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 1+2=3
3+3=6
6+4=10
10+5=15
15+6=21
21+7=28
28+8=36
36+9=45
Option[Int] = Some(45)
reduceLeftOption
同 reduceLeft，返回 Option
var a1 = Array.range(1,10)
a1.reduceLeftOption((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 1+2=3
3+3=6
6+4=10
10+5=15
15+6=21
21+7=28
28+8=36
36+9=45
Option[Int] = Some(45)
reduceRightOption
同 reduceRight，返回 Option
var a1 = Array.range(1,10)
a1.reduceRightOption((x,y)=>{
var z=x+y
println(s"$x+$y=$z")
z
})
> 8+9=17
7+17=24
6+24=30
5+30=35
4+35=39
3+39=42
2+42=44
1+44=45
Option[Int] = Some(45)
reverse
反转序列
a1.reverse.foreach(x => print(x + "\t"));println()
> 9 8 7 6 5 4 3 2 1
reverseIterator
反转序列
反向迭代器
a1.reverseIterator.foreach(x => print(x + "\t"))
> 9 8 7 6 5 4 3 2 1
reverseMap
反向map
a1.reverseMap(x=>print(x + "\t"))
> 9 8 7 6 5 4 3 2 1
> Array((), (), (), (), (), (), (), (), ())
runWith [U] (f:scala.Function1[B,U])
=> scala.Function1[A,scala.Boolean]
调用偏函数
var pf:PartialFunction[Int,Option[String]] = (x:Int) => x match {
case i if i%3==0 => Some("three")
case i if i%7==0 => Some("seven")
case i => None
}
pf.runWith(println)(5) => 输出 None 返回false
pf.runWith(println)(6) => 输出 Some(three) 返回true
#以第二参数下标提取序列元素，作为第一参数函数的入口
#下表存在，且元素符合函数规则返回true
#下表存在，且元素不符合函数规则报异常
#下标不存在返回false
a1.runWith(x=>x match {
casex if x%2==0 => x
})(17)
sameElements(GenSeq):Boolean
两个序列的值是否相同
#长度相同，同一个索引下的值相同
a1.sameElements(a3) > Boolean = false
#重写same方法
def same(a1:Array[Int],a2:Array[Int]):Boolean={
var same:Boolean=true
if (a1.size!=a2.size) {
same = false
}else{
breakable{
for (elem <- 0 until a1.size) {
if (a1(elem)!=a2(elem)) {
same=false
break()
}
}
}
}
same
}
println(same(a1,a3))
scan(initVal)((x,y)=>z)
对集合中的所有元素进行二元计算
#同fold，不同的是会将所有过程结果以数组形式返回，有点像斐波那契数列
a1.scan(0)(_+_) > Array[Int] = Array(0, 1, 3, 6, 10, 15, 21, 28, 36, 45)
scanLeft
对集合中的所有元素从左向右进行二元计算
a1.scanLeft(0)(_+_) > Array[Int] = Array(0, 1, 3, 6, 10, 15, 21, 28, 36, 45)
scanRight
对集合中的所有元素从右向左进行二元计算
a1.scanRight(0)(_+_) > Array[Int] = Array(45, 44, 42, 39, 35, 30, 24, 17, 9, 0)
segmentLength(p:T=>Boolean,fromIndex)
返回一个从fromIndex开始连续满足参数1条件的元素数量
a1.segmentLength(_<5,2) > Int = 2
seq
产生一个特殊集合 WrappedArray
a1.seq > scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)
#scala.collection.immutable.Array
#scala.collection.mutable.ArrayOps #优先
#scala.collection.mutable.WrappedArray
size
返回序列元素个数，同 length
a1.seiz > 9
slice(fromIndex(inclusive),toIndex(exclusize))
截取fronIndex~toIndex之间的元素
a1.slice(2,7) > Array[Int] = Array(3, 4, 5, 6, 7)
sliding(size[,step])
从0开始以step（默认为1）为步伐滑动，并去除从当前位置开始的size个元素
a1.sliding(4).foreach(x=>{x.foreach(y=>print(s"$y,"));println()})
> 1,2,3,4,
2,3,4,5,
3,4,5,6,
4,5,6,7,
5,6,7,8,
6,7,8,9,
#sliding例题
var arr = Array("aaa","male","nanjing",18,2000,"bbb","female","nanjing",28,2500,"ccc","male","zhenjiang",22,2600,"ddd","female","hangzhou",27,3000)
#求不同性别的平均薪资
arr.sliding(5,5).map(x=>(x(1).asInstanceOf[String],x(4).asInstanceOf[Int])).toArray.groupBy(x=>x._1).map(x=>(x._1,x._2.map(x=>x._2).sum*1.0/x._2.length)).foreach(x=>println(s"${x._1}->${x._2}"))
#求不同城市有多少人，分别是谁
arr.grouped(5).map(x=>(x(2).toString,x(0).toString)).toArray.groupBy(x=>x._1).map(x=>(x._1,x._2.length,x._2.map(_._2).mkString("[",",","]"))).foreach(x=>println(s"${x._1},${x._2}人,${x._3}"))
sortBy
按指定的排序规则对序列排序
a3.sortBy(x=>x).foreach(x => print(x + "\t"))
> 1 2 3 4 5
a3.sortBy(x=>(-x)).foreach(x => print(x + "\t"))
> 5 4 3 2 1
sorted
使用默认的排序规则对序列排序，默认升序排列，无参数
a3.sortBy(x=>x).foreach(x => print(x + "\t"))
> 1 2 3 4 5
sortWith
自定义排序方法
a3.sortWith(_>_).foreach(x => print(x + "\t"))
> 5 4 3 2 1
span
将序列拆分为两个数组
#从第一个元素开始，到第一个不满足条件的元素为止，存放于第一个数组
#其他元素放于第二个数组
#如果第一个元素不满足，则第一个数组长度为0
a3.span(_ >= 2)._1.foreach(x => print(x + "\t"))
> 3 5 4
a3.span(_ >= 2)._2.foreach(x => print(x + "\t"))
> 1 2
splitAt
从指定位置开始，将数组拆分为两个数组，指定位置放入第二个数组
a3.splitAt(_ >= 2)._1.foreach(x => print(x + "\t"))
> 1 2
a3.splitAt(_ >= 2)._2.foreach(x => print(x + "\t"))
> 3 5 4
stringPrefix
返回toString()的前缀
a1.stringPrefix.foreach(x=>print(x+"\t"))
> [ I
subSequence(start(inclusive),end(exclusize))
获取start~end字符序列，【只能】用于字符数列
a1.subSequence(1,5)
> 2 3 4 5 6
sum
求和
a1.sum > Int = 45
startsWith
当前序列是否以参数序列开头
a1.startsWith(Array(1,2,3)) > Boolean = true
take
从左边提取n个元素的子序列
a1.take(4) > Array[Int] = Array(1, 2, 3, 4)
takeRight
从右边提取n个元素的子序列
a1.takeRight(4) > Array[Int] = Array(6, 7, 8, 9)
takeWhile
从第一个元素开始，提取满足条件的子序列，遇到第一个不满足条件的结束
a1.takeWhile(_<5) > Array[Int] = Array(1, 2, 3, 4)
tail
返回当前序列中不包含第一个元素的序列，除了头都是尾
a1.tail.foreach(x=>print(x+"\t"));println()
> 2 3 4 5 6 7 8 9
tails
对当前集合进行tail迭代，和inits类似，只不过每一步都是取尾部进行 tail 操作
a3.tails.foreach(x=>{x.foreach(y=>print(s"$y,"));println()})
> 3,5,4,1,2,
5,4,1,2,
4,1,2,
1,2,
2,
toXxx
转化为其他类型，源数据不改变类型
# toArray #转换成 Array 类型 长度固定
# toBuffer #转换成 Buffer 类型 可变长集合
a1.toBuffer > scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
# toIndexedSeq #转换成 IndexedSeq 类型
# toIterable #转换成可迭代的类型
# toIterator #转换成可迭代的类型
# toList #同 List 类型，固定长集合
# toMap #将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型，Tuple2 类型意思是：元组必须是2元的，以元组的第一个元素做键，第二个元素做值
val b8 = Array((1,"a"),(3,"c"),(4,"d"))
b8.foreach(x=>print(x+"\t"));println()
println(b8.toMap)
> (1,a) (3,c) (4,d)
Map(1 -> a, 3 -> c, 4 -> d)
# toSeq #转换成序列
# toSet #将序列转换成 Set 类型，去重
var q1 = Array(1,1,5,5,6,8,7,7,2,2,2)
q1.toSet > scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 8)
# toStream #将序列转换成 Stream 类型（流类型），懒de序列，只存一个值，其他值需要时再取
a1.toStream
> scala.collection.immutable.Stream[Int] = Stream(1, ?)
a1.toStream.head
> Int = 1
a1.toStream.tail
> scala.collection.immutable.Stream[Int] = Stream(2, ?)
# toVector #将序列转换成 Vector 类型，内部线程安全，但效率低
transform(f:Int => Int => Int) :WrappedArray[Int]
将序列中元素转换为指定元素
#类似于map
a1.transform(_*2)
> scala.collection.mutable.WrappedArray[Int] = WrappedArray(2, 4, 6, 8, 10, 12, 14, 16, 18)
transpose
矩阵转置（行转列，列转行）
var q1 = Array(Array(1,2,3),Array(4,5,6),Array(7,8,9))
q1.transpose
> Array[Array[Int]] = Array(Array(1, 4, 7), Array(2, 5, 8), Array(3, 6, 9))
union
union <=> ++
a1.union(a2)
> Array[Any] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18, a, b, c, d)
unzip
将两个元素构成的元组数组的第一和第二个元素分别组成两个数组并封装为元组
var q1 = Array(("aaa",1),("bbb",2),("ccc",3))
q1.unzip
> (Array[String], Array[Int]) = (Array(aaa, bbb, ccc),Array(1, 2, 3))
unzip3
将三个元素构成的元组数组的第一和第二个元素分别组成两个数组并封装为元组
update(pos,v)
将数组中pos下标位置的元素的值改为v，【源数据】改变
a1.update(3,6)
> Array[Any] = Array(1, 2, 3, 6, 5, 6, 7, 8, 9)
updated(pos,v)
将数组中pos下标位置的元素的值改为v，【源数据】不改变
view(fromIndex(inclusive),toIndex(exclusize))
截取fronIndex~toIndex之间的元素
a1.view(2) > Int = 3
a1.view(2,7) > scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(...)
a1.view(2,7).foreach(println) > 3
4
5
6
7
withFilter(p:T=>Boolean)
类似于filter，返回类型不同
=> FilterMonadic[T,Array[T]]
zip
如果两个序列长度相等，将两个序列同一位置元素组成元组数组
var q1 = Array(1,2,3)
var q2 = Array('a','b','c')
q1.zip(q2)
> Array[(Int, Char)] = Array((1,a), (2,b), (3,c))
zipAll (GenSeq,thisElse,thatElse)
同zip，thisElse负责不全this不足，thatElse负责不全that不足
var q1 = Array(1,2,3)
var q2 = Array('a','b','c','d')
q1.zipAll(q2,'M',0) > Array[(AnyVal, AnyVal)] = Array((1,a), (2,b), (3,c), (M,d))
zipWithIndex
序列中的元素和其他的索引构成二元元组数组
var q1 = Array('a','b','c')
q1.zipWithIndex
> Array[(Char, Int)] = Array((a,0), (b,1), (c,2))
特殊符号
++
合并，元数据不变
a1++a2 Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d)
++:
合并，元数据不变
a1++a2 Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d)
a1++:a2 Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d)
:+
尾部追加，冒号只能指向集合
a1:+a2 Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, Array(a, b, c, d))
a1:+a3 Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, Array(3, 5, 4, 1, 2))
a1:+7 Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 7)
+:
头部追加，冒号只能指向集合
a1+:a2 Array[java.io.Serializable] = Array(Array(1, 2, 3, 4, 5, 6, 7, 8, 9), a, b, c, d)
7+:a1 Array[Int] = Array(7, 1, 2, 3, 4, 5, 6, 7, 8, 9)
==
比较地址
var a4 = a3.clone Array[Int] = Array(3, 5, 4, 1, 2)
a4 == a3 Boolean = false
/:
/: <=> fold <=> foldLeft
从左向右累加
:\
:\ <=> foldRight
从右向左累加
a1.foreach(x=>print(x+"\t"))
val add = (x:Int,y:Int)=>{
var z=x+y
println(s"$x+$y=$z")
z
}
println(a1./:(0)(add))
println(a1.:\(0)(add))
扫一扫
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
