本文中所有函数均在cmd中运行,如不适应黑界面可以自行改颜色:color f0
(1)声明一个数组对象
var arr = Array(1,2,3,4,5,6)
//arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
(2)数组++数组:把数组里的元素放到一个数组中,即合并数组,并返回
scala> var c = Array(2,4)
c: Array[Int] = Array(2, 4)
scala> arr++c
res1: Array[Int] = Array(1, 2, 3, 4, 5, 6, 2, 4)
(3)++:合并,右边操纵数的类型决定着返回结果的类型
scala> var arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> var c = List(2,4)
c: List[Int] = List(2, 4)
scala> arr++:c
res0: List[Int] = List(1, 2, 3, 4, 5, 6, 2, 4)
(4)变量+:数组:把变量值加到数组的前面
数组:+变量:把变量值加到数组的后面
scala> var k = 100
k: Int = 100
scala> k+:arr
res2: Array[Int] = Array(100, 1, 2, 3, 4, 5, 6)
scala> arr:+k
res4: Array[Int] = Array(1, 2, 3, 4, 5, 6, 100)
(5)定义一个list型,变量+:list返回list型,数组.++(list)返回数组型
scala> var a = List(3,4,5)
a: List[Int] = List(3, 4, 5)
scala> k+:a
res8: List[Int] = List(100, 3, 4, 5)
scala> c.++(a)
res7: Array[Int] = Array(2, 4, 3, 4, 5)
(6)/:对数组中所有元素进行相同的操作(foldLeft的简写)
:\(foldRight的简写)
scala> var k = 100
k: Int = 100
scala> val a = List(3,4,5)
a: List[Int] = List(3, 4, 5)
scala> (100 /: a)(_+_)
res9: Int = 112 //3+4+5+100
scala> (a :\ 100)(_*_)
res11: Int = 6000 //5*4*3*100
(7)addString把数组中的元素逐个添加到str中,中间用“#”(分隔符)隔开
scala> var str = new StringBuilder
str: StringBuilder =
scala> a.addString(str)
res12: StringBuilder = 345
scala> str
res13: StringBuilder = 345
scala> a.addString(str,"#")
res14: StringBuilder = 3453#4#5
(8)addString(str,start,seq,end)首尾和中间不同位置
在不同位置指定不同字符
scala> var str = ""
str: String = ""
scala> var str = new StringBuilder
str: StringBuilder =
scala> a.addString(str,"[",",","]");
res15: StringBuilder = [3,4,5]
(9)apply取出指定索引处的元素
scala> var c = Array(1,2,3,4,5,6)
c: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> c.apply(2)
res16: Int = 3
(10)canEqual判断两个对象是否可以比较
scala> val d = Array(2,3,45,5)
d: Array[Int] = Array(2, 3, 45, 5)
scala> c
res18: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> c.canEqual(d)
res17: Boolean = true
scala> c.canEqual(10)
res19: Boolean = true
scala> c.canEqual("aa")
res20: Boolean = true
scala> c.canEqual('z')
res21: Boolean = true
scala> object myObj{}
defined object myObj
scala> c.canEqual(myObj)
res22: Boolean = true
(11)charAt获取索引处的字符
这个方法会执行一个隐式转换,将Array[T]转换为ArrayCharSequence,只有当T为char类型时,这个转换才会发生
scala> var e = Array('a','b','c')
e: Array[Char] = Array(a, b, c)
scala> e.charAt(2)
res23: Char = c
(12)clone创建一个副本,创建后的副本不因原值的变动而改动
scala> var e = c
e: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> c
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> c(2) = 44
scala> c
res27: Array[Int] = Array(1, 2, 44, 4, 5, 6)
scala> e
res28: Array[Int] = Array(1, 2, 44, 4, 5, 6)
scala> var k = c.clone
k: Array[Int] = Array(1, 2, 44, 4, 5, 6)
scala> c(2) = 100
scala> k
res30: Array[Int] = Array(1, 2, 44, 4, 5, 6)
(13)collect通过执行一个偏函数,得到一个新的数组对象
scala> c
res31: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> val fun:PartialFunction[Int,Int]={ //偏函数定义
| case x => x+1
| }
fun: PartialFunction[Int,Int] = <function1>
scala> c.collect(fun)
res32: Array[Int] = Array(2, 3, 101, 5, 6, 7)
scala> val fun:PartialFunction[Int,Int]={
| case 2 => 1
| case y if y % 2 == 0 => y+50
| case x => x
| }
fun: PartialFunction[Int,Int] = <function1>
scala> c.collect(fun)
res33: Array[Int] = Array(1, 1, 150, 54, 5, 56)
scala> val fun:PartialFunction[Int,String]={
| case 1 =>"xixi"
| case y if y%2 == 0 => "gg"
| case x => x+ "ff"
| }
fun: PartialFunction[Int,String] = <function1>
scala> c.collect(fun)
res34: Array[String] = Array(xixi, gg, gg, gg, 5ff, gg)
(14)collectFirst在序列中查找第一个符合偏函数定义的元素,并执行偏函数计算
scala> arr
res8: Array[Any] = Array(1, a, b)
scala> val value = arr.collectFirst({case x:Int => x*100})
value: Option[Int] = Some(100)
scala> var arr = Array(2,'a',"b")
arr: Array[Any] = Array(2, a, b)
scala> val value = arr.collectFirst({case x:Int => x* 100})
value: Option[Int] = Some(200)
(15)combinations(n)选出所有包含字符不一样的组合,n表示组合的长度
mkstring(",")把元素用特殊符号拼起来
scala> val arr = Array("a","b","c")
arr: Array[String] = Array(a, b, c)
scala> val nw = arr.combinations(2)
nw: Iterator[Array[String]] = non-empty iterator
scala> nw.foreach((x)=>println(x.mkString(",")))
a,b
a,c
b,c
scala> c
res36: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.mkString(",")
res37: String = 1,2,100,4,5,6
(16)contains是否包含特定元素
scala> c
res39: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.contains(50)
res40: Boolean = false
scala> c.contains(100)
res41: Boolean = true
(17)containsSlice数组里是否包含另一个数组
scala> c
res43: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> var d = Array(2,4,5)
d: Array[Int] = Array(2, 4, 5)
scala> c.containsSlice(d)
res42: Boolean = false
scala> var d = Array(4,5)
d: Array[Int] = Array(4, 5)
scala> c.containsSlice(d)
res44: Boolean = true
(18)c.copyToArray(a,n)从第n个元素开始把c拷贝给a
此外还可设定copy长度即c.copyToArray(a,n,l),l代表长度
scala> c
res45: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> val a = Array(0,0,0,0,0,0)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0)
scala> c.copyToArray(a,2)
scala> a
res47: Array[Int] = Array(0, 0, 1, 2, 100, 4)
(19)copyToBuffer把数组中的内容拷贝到buffer中
scala> c
res48: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val a = ArrayBuffer(0,0,0,0,0,0)
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 0, 0, 0, 0, 0)
scala> c.copyToBuffer(a)
scala> a
res54: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(0, 0, 0, 0, 0, 0, 1, 2, 100, 4, 5, 6)
(20)corresponds判断数组长度是否相等,并且对应位置的元素是否满足某种条件
scala> c
res57: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> val a = Array(0,0,0,0,0,0)
a: Array[Int] = Array(0, 0, 0, 0, 0, 0)
scala> c.corresponds(a)(_==_)
res58: Boolean = false
(21)count统计满足条件的个数
scala> c
res59: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.count(p=>p%2==0) //偶数
res60: Int = 4
(22)diff返回c中不同于a的数组
scala> c
res61: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> var a = Array(2,4,5)
a: Array[Int] = Array(2, 4, 5)
scala> c.diff(a)
res64: Array[Int] = Array(1, 100, 6)
(23)remove去除某个位置的元素
remove(m,n)m表示下标,n表示元素个数
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val a = ArrayBuffer(1,2,3)
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
scala> a.remove(1)
res67: Int = 2
scala> a
res68: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3)
(24)distinct 去重:去除重复元素只保留一个
scala> val m = Array(1,1,2,3,3,3,4,4)
m: Array[Int] = Array(1, 1, 2, 3, 3, 3, 4, 4)
scala> val n = m.distinct
n: Array[Int] = Array(1, 2, 3, 4)
(25)drop删除前n个元素,并返回
dropRight去掉尾部的n个元素,并返回
scala> n
res71: Array[Int] = Array(1, 2, 3, 4)
scala> val p = n.drop(2)
p: Array[Int] = Array(3, 4)
(26)dropWhile去除当前数组中符合条件的元素,从数组的第一个条件起就要满足条件,直到第一个不满足条件的元素为止,若第一个元素不符合条件,就返回整个数组
scala> val c = Array(1,2,100,4,5,6)
c: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.dropWhile(p=>p%2==1)
res1: Array[Int] = Array(2, 100, 4, 5, 6)
(27)endsWith判断是否以某个序列结尾
startsWith判断是否以某个序列开头
scala> val m = Array(2,3,4)
m: Array[Int] = Array(2, 3, 4)
scala> val n = Array(3,2,3,4)
n: Array[Int] = Array(3, 2, 3, 4
scala> n.endsWith(m)
res4: Boolean = true
scala> n.startsWith(m)
res5: Boolean = false
(27)exists判断当前数组是否包含符合条件的元素
scala> c
res6: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.exists(p=>p>5)
res7: Boolean = true
(28)filter取得当前数组中符合条件的元素,组成新的数组返回
withFilter§根据条件p过滤元素
scala> c
res8: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> c.filter(p=>p%2 == 0)
res9: Array[Int] = Array(2, 100, 4, 6)
scala> def myfun(p:Int):Boolean = {
| p%2 == 0
| }
myfun: (p: Int)Boolean
scala> c.filter(myfun)
res10: Array[Int] = Array(2, 100, 4, 6)
(28)find查找第一个符合条件的元素
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val a = ArrayBuffer(1,100,4,5,6)
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 100, 4, 5, 6)
scala> c
res13: Array[Int] = Array(1, 2, 100, 4, 5, 6)
scala> a.find(x=>x==2)
res14: Option[Int] = None
scala> c.find(x=>x==2)
res15: Option[Int] = Some(2)
scala> c.find(x=>x==2).get
res16: Int = 2
(29)flatMap和Map(是否降维)
map对序列中的元素进行某操作
scala> val c = Array(1,2,3)
c: Array[Int] = Array(1, 2, 3)
scala> c.flatMap(x=>(1 to x))
res17: Array[Int] = Array(1, 1, 2, 1, 2, 3)//第一次1;第二次1,2;第三次1,2,3
scala> c.map(x=>(1 to x))
res18: Array[scala.collection.immutable.Range.Inclusive] = Array(Range(1), Range(1, 2), Range(1, 2, 3))
(30)flatten将二维数组变成一维数组
scala> val p = c.map(x=>(1 to x))
p: Array[scala.collection.immutable.Range.Inclusive] = Array(Range(1), Range(1, 2), Range(1, 2, 3))
scala> val q = p.flatten
q: Array[Int] = Array(1, 1, 2, 1, 2, 3)
(31)fold对数组中的每个元素进行计算
scala> c
res19: Array[Int] = Array(1, 2, 3)
scala> c.fold(5)(_+_)
res20: Int = 11
//运算过程
5+1=6
6+2=8
8+3=11
scala> def myfun(m:Int,n:Int):Int={
| m+n
| }
myfun: (m: Int, n: Int)Int
scala> c.fold(5)(myfun)
res21: Int = 11
(32)aggregate先分组再聚合
scala> val m = Array(1,2,3,4)
m: Array[Int] = Array(1, 2, 3, 4)
scala> val c = m.par.aggregate(5)(_+_,_+_)
c: Int = 30(有时会出现25,错误)
//运算过程
5+1=6
5+2=7
5+3=8
5+4=9
8+6=14
7+9=15
(33)forall检查序列中的元素是否都满足某个条件,如果序列为空,返回true
scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b = a.forall({x:Int => x>0})
b: Boolean = true
scala> val b = a.forall({x:Int => x>2})
b: Boolean = false
(34)foreach遍历序列中的元素,并进行一定的操作
scala> val a = Array(1,2,3,4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> a.foreach(x=>println(x*10))
10
20
30
40
(35)分组
groupBy按条件分组
grouped按指定数量分组
scala> val k = Array(1,2,3,4,5,6)
k: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> k.groupBy(x=> x match{ //按奇偶性分
| case x if x%2 ==0 => "ou"
| case _ => "ji"
| })
res25: scala.collection.immutable.Map[String,Array[Int]] = Map(ou -> Array(2, 4, 6), ji -> Array(1, 3, 5))
scala> k.grouped(3) //每组3个
res26: Iterator[Array[Int]] = non-empty iterator
scala> k.grouped(3).foreach(x=>println(x))
[I@734ab79
[I@5fa8a0b4
scala> k.grouped(3).foreach(x=>println(x.mkString(",")))
1,2,3
4,5,6
(36)head返回序列的第一个元素,若序列为空,则报错
scala> k
res29: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> k.head
res30: Int = 1
(37)tail和last
tail指除head外剩下的其他元素组成的集合
last指序列中最后一个元素
scala> k
res32: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> k.tail
res31: Array[Int] = Array(2, 3, 4, 5, 6)
scala> k.last
res33: Int = 6
(38)headOption返回some()或者none,为空则为none
scala> var lst = ArrayBuffer()
lst: scala.collection.mutable.ArrayBuffer[Nothing] = ArrayBuffer()
scala> lst.headOption
res34: Option[Nothing] = None
(39)indexOf返回元素在序列中的索引,可以指定从某个索引处开始查找,找到第一个就返回
scala> val a = Array(1,3,4,5,3,1)
a: Array[Int] = Array(1, 3, 4, 5, 3, 1)
scala> a.indexOf(3,4)
res3: Int = 4
(40)indexOfSlice检验序列中是否包含另一个序列,并返回第一个匹配出现的元素的索引
indexWhere返回当前序列中第一个满足 p 条件的元素的索引
scala> val a = (1 to 20)
a: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
scala> a.indexOfSlice((4 to 6))
res35: Int = 3
scala> a.indexWhere(p=>p>10)
res36: Int = 10
(41)init返回当前序列中不包含最后一个元素的序列
scala> val a = (1 to 20)
a: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
scala> a.init
res0: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
42)intersect取两个集合的交集
scala> var b = (10 to 15)
b: scala.collection.immutable.Range.Inclusive = Range(10, 11, 12, 13, 14, 15)
scala> var a = (13 to 19)
a: scala.collection.immutable.Range.Inclusive = Range(13, 14, 15, 16, 17, 18, 19)
scala> a.intersect(b)
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(13, 14, 15)
43)isDefinedAt数组中是否有这个下标
scala> a
res4: scala.collection.immutable.Range.Inclusive = Range(13, 14, 15, 16, 17, 18, 19)
scala> a.isDefinedAt(20)
res2: Boolean = false
scala> a.isDefinedAt(2)
res3: Boolean = true
44)isEmpty判断数组是否为空
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> val c = ArrayBuffer()
c: scala.collection.mutable.ArrayBuffer[Nothing] = ArrayBuffer()
scala> c.isEmpty
res5: Boolean = true
45)isTraversableAgain判断序列是否可以反复遍历,对于Traverables一般返回true,对于Iterators返回false
scala> val arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.isTraversableAgain
res6: Boolean = true
46)iterator对序列中的每个元素产生一个迭代器
scala>val b = arr.iterator
res7: Iterator[Int] = non-empty iterator //产生迭代器后可以通过迭代器访问b
47)inits对集合中的元素进行 init 操作,该操作的返回值中, 第一个值是当前序列的副本,包含当前序列所有的元素,最后一个值是空的,对头尾之间的值进行init操作,上一步的结果作为下一步的操作对象
scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> val b = a.inits.toList
b: List[Array[Int]] = List(Array(1, 2, 3), Array(1, 2), Array(1), Array())
48)lengthCompare(len)比较序列的长度和参数len,根据二者的关系返回不同的值
scala> arr
res11: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.lengthCompare(5)
res9: Int = 1
scala> arr.lengthCompare(6)
res12: Int = 0
scala> arr.lengthCompare(7)
res10: Int = -1
scala> arr.lengthCompare(8)
res13: Int = -2
49)scala实现wordcount
scala> val str = "hello mysql hello world"
str: String = hello mysql hello world
scala> str.split(" ").map(x=>(x,1))
res14: Array[(String, Int)] = Array((hello,1), (mysql,1), (hello,1), (world,1))
scala> str.split(" ").map(x=>(x,1)).groupBy(x=>x._1).foreach(x=>{print(x._1,x._2.length)})
(world,1)(mysql,1)(hello,2)
50)max返回序列中最大的元素
maxBy返回序列中第一个符合条件的最大的元素
scala> arr
res16: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.max
res17: Int = 6
scala> val b = Array(1,2,4,2,3,6)
b: Array[Int] = Array(1, 2, 4, 2, 3, 6)
scala> println(b.maxBy({x:Int => x>2}))
4
51)nonEmpty判断序列不是空
scala> arr
res18: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.nonEmpty
res19: Boolean = true
52)padTo(m,n)后补齐序列,需要一个长度为m的新序列,空出的填n
A.copyToArray(B,1,2)从下标为1的位置把A中的元素拷贝给B,长度为2
scala> val arr1 = Array(1,2,3)
arr1: Array[Int] = Array(1, 2, 3)
scala> val a1 = arr.padTo(10,0)
a1: Array[Int] = Array(1, 2, 3, 4, 5, 6, 0, 0, 0, 0)
scala> arr1.copyToArray(a1,5,3)
scala> a1
res21: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3, 0, 0)
53)partititon
按条件将序列拆分为两个新的序列,满足条件的放到第一个序列,其余的放入第二个序列
scala> arr
res22: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.partition(_%2==0)
res23: (Array[Int], Array[Int]) = (Array(2, 4, 6),Array(1, 3, 5))
54)patch批量替换
scala> arr
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr1
res25: Array[Int] = Array(1, 2, 3)
scala> arr.patch(3,arr1,2)
res26: Array[Int] = Array(1, 2, 3, 1, 2, 3, 6)
//从arr的第4个元素开始,取两个元素,即4和5,这两个元素替换为arr1的内容
55)permuntations排列组合
组合内的内容可以相同,但顺序不能相同
scala> arr1.permutations.toList
res28: 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))
56)prefixLength§
给定一个条件p,返回一个前置数列的长度,这个数列中的元素都满足p
scala> arr
res31: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.prefixLength(_<4)
res30: Int = 3
57)product返回所有元素乘积的值
sum返回所有元素和的值
scala> (1 to 5).product
res32: Int = 120
scala> (1 to 5).sum
res33: Int = 15
58)reduce
对序列中的每个元素进行二元运算,无初始值
reduceLeft从左往右计算;reduceRight从右往左计算
reduceLeftOption和reduceRightOption计算Option,计算方向不同
scala> arr
res34: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.reduce(_+_)
res35: Int = 21
/**
1+2=3;3+3=6;6+4=10;10+5=15;15+6=21
*/
scala> arr.reduce(_-_)
res36: Int = -19
/**
1-2=-1;-1-3=-4;-4-4-=-8;-8-5=-13;-13-6=-19
*/
59)reserve 反转
reverseIterator 反向生成迭代
scala> arr
res37: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.reverse
res38: Array[Int] = Array(6, 5, 4, 3, 2, 1)
60)reserverMap((_,1))与map方向相反
scala> arr
res39: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.reverseMap((_,1))
res40: Array[(Int, Int)] = Array((6,1), (5,1), (4,1), (3,1), (2,1), (1,1))
61)sameElements判断两个序列是否顺序和对应位置上的元素都一样
scala> val arr2 = arr.clone
arr2: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.sameElements(arr2)
res41: Boolean = true
62)segmentLength(p,from)
从序列的from处开始向后查找,所有满足p的连续元素的长度
scala> arr
res42: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.segmentLength(_<4,1)
res43: Int = 2
63)seq产生一个引用当前序列的sequential视图
scala> arr
res44: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.seq
res45: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 6)
64)sliding(size,步长)
从第一个元素开始,每个元素和它后面的size-1个元素组成一个数组,最终组成一个新的集合返回,当剩余元素不够size数,则停止
scala> arr
res47: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.sliding(3).foreach(x=>println(x.mkString(",")))
1,2,3
2,3,4
3,4,5
4,5,6
scala> arr.sliding(3,3).foreach(x=>println(x.mkString(",")))
1,2,3
4,5,6
scala> arr.sliding(3,2).foreach(x=>println(x.mkString(",")))
1,2,3
3,4,5
5,6
scala> arr.sliding(3,4).foreach(x=>println(x.mkString(",")))
1,2,3
5,6
65)sortBy按指定的排序规则排序
scala> arr
res52: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.sortBy(x=>x)
res53: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> arr.sortBy(x=>0-x)
res54: Array[Int] = Array(6, 5, 4, 3, 2, 1)
scala> var arr = Array("hello","world","are")
arr: Array[String] = Array(hello, world, are)
scala> arr.sortBy(x=>x)
res55: Array[String] = Array(are, hello, world)
scala> var arr1 = arr:+20:+"abc"
arr1: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1.sortBy(x=>x)
<console>:15: error: No implicit Ordering defined for Any.
arr1.sortBy(x=>x)
66)sortWith自定义排序方法
scala> arr1.map(x=>x+"").sortWith(_.compareTo(_)>0)
res57: Array[String] = Array(world, hello, are, abc, 20)
scala> def mycomp(x:Any,y:Any):Boolean = {
| x.asInstanceOf[String] >y.asInstanceOf[String]
| }
mycomp: (x: Any, y: Any)Boolean
scala> mycomp("abc",20)
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at .mycomp(<console>:13)
... 32 elided
scala> def mycomp(x:Any,y:Any):Boolean ={
| x+"" >y+ ""
| }
mycomp: (x: Any, y: Any)Boolean
scala> mycomp("abc",20)
res59: Boolean = true
scala> arr.sortWith(mycomp)
res60: Array[String] = Array(world, hello, are)
scala> def mycomp(x:Any,y:Any):Boolean ={
| x.toString>y.toString
| }
mycomp: (x: Any, y: Any)Boolean
scala> mycomp("abc",24)
res61: Boolean = true
scala> arr1
res62: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1.partition(x=>x.isInstanceOf[String])
res63: (Array[Any], Array[Any]) = (Array(hello, world, are, abc),Array(20))
67)span分割序列为两个集合,从第一个元素开始,直到找到第一个不满足条件的元素止,之前的元素放到第一个集合,其它的放到第二个集合
scala> arr1
res64: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1.span(_.isInstanceOf[String])
res65: (Array[Any], Array[Any]) = (Array(hello, world, are),Array(20, abc))
68)splitAt从指定位置开始把序列拆分为两个集合
scala> arr1.splitAt(3)
res67: (Array[Any], Array[Any]) = (Array(hello, world, are),Array(20, abc))
scala> arr
res69: Array[String] = Array(hello, world, are)
scala> arr.splitAt(2)
res68: (Array[String], Array[String]) = (Array(hello, world),Array(are))
69)startsWith从指定偏移处是否以某个序列开始
endsWith判断是否以某个序列结尾
scala> val t1 = Array("world","are")
t1: Array[String] = Array(world, are)
scala> arr1
res70: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr.startsWith(t1)
res71: Boolean = false
scala> arr.startsWith(t1,1)
res72: Boolean = true
scala> arr1
res73: Array[Any] = Array(hello, world, are, 20, abc)
scala> val t2 = Array("are",20)
t2: Array[Any] = Array(are, 20)
scala> arr1.endsWith(t2)
res77: Boolean = false
//endsWith无法加偏移量
70)stringPrefix返回toString结果的前缀
scala> "abcd".stringPrefix
res78: String = String
scala> "243".stringPrefix
res79: String = String
71)subSequence返回start和end间的字符序列
scala> var chars = Array('a','b','c','d')
chars: Array[Char] = Array(a, b, c, d)
scala> val b = chars.subSequence(1,3)
b: CharSequence = bc
scala> println(b.toString)
bc
72)take返回当前序列中前n个元素组成的序列
slice
scala> arr1
res81: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1.take(3)
res82: Array[Any] = Array(hello, world, are)
scala> arr1.slice(1,3)
res83: Array[Any] = Array(world, are)
73)takeRight返回当前序列中,从右边开始,选择n 个元素组成的序列
scala> arr1
res85: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1.takeRight(3)
res84: Array[Any] = Array(are, 20, abc)
74)takeWhile返回当前序列中,从第一个元素开始,满足条件的连续元素组成的序列
scala> arr1.takeWhile(_.isInstanceOf[String])
res86: Array[Any] = Array(hello, world, are)
75)transpose
矩阵转换,二维数组行列转换
scala> val ar = Array(Array(3,4,5),Array(7,8,9),Array(10,11,12))
ar: Array[Array[Int]] = Array(Array(3, 4, 5), Array(7, 8, 9), Array(10, 11, 12))
scala> ar.transpose
res87: Array[Array[Int]] = Array(Array(3, 7, 10), Array(4, 8, 11), Array(5, 9, 12))
76)unzip(只能2*2,且必须是数组套元组)
将含有两个元素的数组,第一个元素取出组成一个序列,第二个元素组成一个序列
scala> val ar1 = Array((3,4),(7,8))
ar1: Array[(Int, Int)] = Array((3,4), (7,8))
scala> ar1.unzip
res88: (Array[Int], Array[Int]) = (Array(3, 7),Array(4, 8))
77)update(i,x)将序列中i索引处的元素更新为x
scala> arr1
res89: Array[Any] = Array(hello, world, are, 20, abc)
scala> arr1(3) = 60
scala> arr1
res91: Array[Any] = Array(hello, world, are, 60, abc)
scala> arr1.update(3,80)
scala> arr1
res93: Array[Any] = Array(hello, world, are, 80, abc)
78)updated(i,x)将序列中i索引处的元素更新为x,并返回替换后的数组
scala> arr1.updated(3,100)
res94: Array[Any] = Array(hello, world, are, 100, abc)
scala> arr1
res95: Array[Any] = Array(hello, world, are, 80, abc)
79)view(a,b)返回a到b间的序列,不包括until处的元素
scala> arr1
res96: Array[Any] = Array(hello, world, are, 80, abc)
scala> arr1.view(1,3).foreach(x=>println(x))
world
are
80)zip将两个序列对应位置上的元素组成一个pair序列
scala> t1
res98: Array[String] = Array(world, are)
scala> t2
res99: Array[Any] = Array(are, 20)
scala> t1.zip(t2)
res100: Array[(String, Any)] = Array((world,are), (are,20))
scala> val t3 = Array(1,2,3,4,5)
t3: Array[Int] = Array(1, 2, 3, 4, 5)
scala> t3.zip(t1)
res101: Array[(Int, String)] = Array((1,world), (2,are))
81)zipAll(b,a,b),同zip,但是允许两个序列长度不一样,不足的自动填充,如果当前序列端,空出的填充为a,如果b短,填充为b
scala> t3
res102: Array[Int] = Array(1, 2, 3, 4, 5)
scala> t1
res103: Array[String] = Array(world, are)
scala> t1.zipAll(t3,0,3)
res104: Array[(Any, Int)] = Array((world,1), (are,2), (0,3), (0,4), (0,5))
82)zipWithIndex
序列中的每个元素和它的索引组成一个序列
scala> t3
res105: Array[Int] = Array(1, 2, 3, 4, 5)
scala> t3.zipWithIndex
res106: Array[(Int, Int)] = Array((1,0), (2,1), (3,2), (4,3), (5,4))
83)transform数组中的每个元素加
scala> val n = arr.transform(_+"10")
n: scala.collection.mutable.WrappedArray[String] = WrappedArray(hello10, world10, are10)
84)hasDefiniteSize 检测序列是否存在有限的长度,对应Stream这样的流数据
scala> a
res13: Array[Int] = Array(1, 2, 3)
scala> println(a.hasDefiniteSize)
true
85)类型转换
toArray 转换成Array类型
toBuffer 转换成Buffer类型
toIndexedSeq 转换成IndexedSeq类型
toIterable 转换成可迭代的类型
toIterator 同iterator方法
toList 同List类型
toMap 同Map类型,需要被转化序列中包含的元素是元组2类型数据
toSeq 同Seq类型
toSet 同Set类型
toStream 同Stream类型
toVector 同Vector类型
86)min返回序列中最小的元素
minBy返回序列中第一个不符合条件的元素
scala> val a = Array(3,2,1,4,3,2)
a: Array[Int] = Array(3, 2, 1, 4, 3, 2)
scala> a.minBy(_<3)
res31: Int = 3
scala> a.minBy(_>3)
res32: Int = 3
scala> a.minBy(_>=3)
res33: Int = 2
87)scan把每一步的计算结果放到一个新的集合中返回
scanLeft从左往右计算,scanRight从右往左计算
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> val b = a.scan(5)(_+_)
b: Array[Int] = Array(5, 6, 8, 11, 15, 20)
88)indices返回当前序列索引集合
scala> val a = Array(1,2,1,4,3)
a: Array[Int] = Array(1, 2, 1, 4, 3)
scala> val b = a.indices
b: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)
89)size 序列元素个数,同length
scala> a
res36: Array[Int] = Array(1, 2, 1, 4, 3)
scala> a.size
res37: Int = 5
scala> a.length
res43: Int = 5
90)lastIndexOf取得序列中最后一个等于某个元素的位置
lastIndexOfSlice判断当前序列中是否包含另一个序列,并返回最后一次出现该序列的位置处的索引
scala> val a = Array(1,4,2,3,4,5)
a: Array[Int] = Array(1, 4, 2, 3, 4, 5)
scala> a.lastIndexOf(4,3)
res38: Int = 1
scala> val a = Array(1,4,2,3,4,5,1,4)
a: Array[Int] = Array(1, 4, 2, 3, 4, 5, 1, 4)
scala> val b = Array(1,4)
b: Array[Int] = Array(1, 4)
scala> a.lastIndexOfSlice(b)
res39: Int = 6
91) lastIndexWhere返回当前序列中最后一个满足条件p的元素的索引
scala> val a = Array(1,4,2,3,4,5,1,4)
a: Array[Int] = Array(1, 4, 2, 3, 4, 5, 1, 4)
scala> val b = Array(1,4)
b: Array[Int] = Array(1, 4)
scala> a.lastIndexWhere({x:Int => x<2},2)
res40: Int = 0
92)lastOption返回当前序列中最后一个对象
scala> val a = Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.lastOption
res41: Option[Int] = Some(5)