scala中函数算子示例详解

最新推荐文章于 2023-03-17 16:51:18 发布

dontlikerabbit

最新推荐文章于 2023-03-17 16:51:18 发布

阅读量1.2k

点赞数 1

文章标签： scala

本文链接：https://blog.csdn.net/dontlikerabbit/article/details/111761162

版权

scala> var a1 = Array(“a”,“b”,“c”)
a1: Array[String] = Array(a, b, c)

scala> var a2 =Array(“1”,“2”,“3”)
a2: Array[String] = Array(1, 2, 3)

++ 和++：两个集合合并，基本上没有区别，:后指向类型

scala> a1++a2
res0: Array[String] = Array(a, b, c, 1, 2, 3)

scala> a1++:a2
res1: Array[String] = Array(a, b, c, 1, 2, 3)

scala> var a3:Array[Byte] =Array(1,2,3)
a3: Array[Byte] = Array(1, 2, 3)

scala> var a4:Array[Short] =Array(4,5,6)
a4: Array[Short] = Array(4, 5, 6)

scala> a3++a4
res2: Array[AnyVal] = Array(1, 2, 3, 4, 5, 6)

scala> a3++:a4
res3: Array[AnyVal] = Array(1, 2, 3, 4, 5, 6)

scala> a4++:a3
res4: Array[AnyVal] = Array(4, 5, 6, 1, 2, 3)

:+ 尾部追加 +：头部追加

scala> a3:+5
res6: Array[AnyVal] = Array(1, 2, 3, 5)

scala> 7+:a3
res7: Array[AnyVal] = Array(7, 1, 2, 3)

clone 克隆一份数据

scala> a3
res10: Array[Byte] = Array(1, 2, 3)

scala> var a5 = a3.clone
a5: Array[Byte] = Array(1, 2, 3)

scala> a5
res11: Array[Byte] = Array(1, 2, 3)

== 判断地址是否相等，返回布尔值

scala> 1==1
res8: Boolean = true

scala> a3==a5
res12: Boolean = false

eq判断值是否相等多于引用类型，和==是一样的效果，如果想引用类型值比较，用sameElement

scala> a3.eq(a5)
res13: Boolean = false

#sameElements 两个集合的值比较，只要一个值不一样就返回false

var a3 = Array.range(1,5)
var a4 = Array(1,2,2,4)

println(a3.sameElements(a4))

#canEqual 判断两个值是否能比较
scala> a1.canEqual(a2)
res7: Boolean = true

(n)//apply(n)取数组中下标位置的值，注意不能下标越界

applyOrElse(n,{i:Type=>“DEFAULT_VALUE”}) 取数组中下标位置的值，不存在则返回DEFAULT_VALUE

scala> var a1=Array(1,2,3)
a1: Array[Int] = Array(1, 2, 3)

scala> a1(2)
res2: Int = 3

scala> a1.apply(2)
res3: Int = 3

scala> a1.applyOrElse(0,{i:Int=>“NONE”})
res4: Any = 1

scala> a1.applyOrElse(3,{i:Int=>“NONE”})
res5: Any = NONE

charAt(n) 取字符数组中下标位置的字符，也要注意下标不能越界

scala> var arr = Array(‘a’,‘b’,‘c’)
arr: Array[Char] = Array(a, b, c)

scala> arr.charAt(0)
res8: Char = a

collect(条件) 收集数组中符合条件的所有值

collectFirst(条件) 收集数组中第一个符合条件的值

a1:Array[Int] = Array(1, 2, 3, 4)

scala> a1.collect({case i if i%2==0 =>i})
res12: Array[Int] = Array(2, 4)

scala> a1.collectFirst({case i if i%2==0 =>i})
res13: Option[Int] = Some(2)

permutations 排序

scala> var a2=Array(1,2,3,4,5,6,7,8,9)
a2: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> a2.permutations
res14: Iterator[Array[String]] =

scala> a2.permutations.toArray
res15: Array[Array[String]] = Array(Array(1, 2, 3), Array(1, 3, 2), Array(2, 1, 3), Array(2, 3, 1), Array(3, 1, 2), Array(3, 2, 1))

contains(值) 判断数组中是否包含一个值

scala> a1
res16: Array[String] = Array(a, b, c)

scala> a1.contains(“a”)
res20: Boolean = true

scala> a1.contains(3)
res18: Boolean = false

containsSlice 判断是否包含整个序列

scala> a6
res34: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> var a7 = Array(1,2,3)
a7: Array[Int] = Array(1, 2, 3)

scala> a6.containsSlice(a7)
res35: Boolean = true

corresponds(序列)(条件) 判断两集合长度相等且同一位置上两集合满足条件

scala> var ac = a6.clone
ac: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> a6.corresponds(ac)(==)
res36: Boolean = true

scala> ac=ac.map(_+1)
ac: Array[Int] = [I@3e0b3dde

scala> a6.corresponds(ac)(==)
res37: Boolean = false

scala> a6.corresponds(ac)(<)
res38: Boolean = true

scala> ac(3)=0

scala> ac
res40: Array[Int] = Array(2, 3, 4, 0, 6, 7)

scala> a6.corresponds(ac)(<)
res41: Boolean = false

聚合函数count(条件) 数组中符合条件的个数，当条件有两个不能用两个_,要用函数

scala> ac.count(_>5)
res42: Int = 2

scala> ac.count(_>2 && <5)
:13: error: missing parameter type for expanded function ((x$1: , x$2) => x $1 .$ greater(2). $a m p$ amp(x $2 .$ less(5)))
ac.count(>2 && <5)
^
:13: error: missing parameter type for expanded function ((x$1: , x$2: ) => x $1 .$ greater(2). $a m p$ amp(x $2 .$ less(5)))
ac.count(>2 && _<5)

scala> ac.count(x=>x>2 && x<5)
res46: Int = 2

diff 差集 intersect 交集

scala> a6
res51: Array[Int] = Array(1, 2, 3, 4, 5, 6)

scala> ac
res52: Array[Int] = Array(2, 3, 4, 0, 6, 7)

scala> a6.diff(ac)
res53: Array[Int] = Array(1, 5)

scala> a6.intersect(ac)
res54: Array[Int] = Array(2, 3, 4, 6)

distinct 去重

scala> a6++ac
res55: Array[Int] = Array(1, 2, 3, 4, 5, 6, 2, 3, 4, 0, 6, 7)

scala> res55
res56: Array[Int] = Array(1, 2, 3, 4, 5, 6, 2, 3, 4, 0, 6, 7)

scala> res55.distinct
res57: Array[Int] = Array(1, 2, 3, 4, 5, 6, 0, 7)

drop(n)删除左边n个值//dropRight(n)删除右边n个值

dropWhile#删除第一个符合条件的数，直到不符合条件的，若第一个就不符合，则不删除

scala> res55.drop(2)
res58: Array[Int] = Array(3, 4, 5, 6, 2, 3, 4, 0, 6, 7)

scala> res58.dropRight(2)
res59: Array[Int] = Array(3, 4, 5, 6, 2, 3, 4, 0)

scala> res59.dropWhile(_%2==1)
res60: Array[Int] = Array(4, 5, 6, 2, 3, 4, 0)

/: fold foldLeft 从左向右累加

: / foldRight 从右向左累加

  val add = (x:Int,y:Int)=>{
  var z= x+y
  println(s"$x+$y=$z")
  z
}

println(a3./:(0)(add))
println(a3.foldLeft(0)(add))
println(a3.fold(0)(add))
	0+1=1
	1+2=3
	3+3=6
	6+4=10
	10
println(a3.foldLeft(a4.fold(0)(add))(add))
	0+1=1
	1+2=3
	3+3=6
	6+4=10
	10+1=11
	11+2=13
	13+3=16
	16+4=20
	20

println(a3.foldRight(0)(add))
	4+0=4
	3+4=7
	2+7=9
	1+9=10
	10

addString 将数组拼接成字符串，需要new 一个对象

mkString 将数组拼接成字符串

import scala.collection.mutable.StringBuilder
var builder =new mutable.StringBuilder
a3.addString(builder,"[",",","]")
println(builder)
	[1,2,3,4]
println(a3.mkString("[","-","]"))
	[1-2-3-4]

aggregate 聚合加par产生分区

var lst = new ArrayBuffer[Int]
for (elem <- 1 to 10) {
  lst.append(Random.nextInt(20))
}

println(lst)
ArrayBuffer(14, 7, 8, 19, 12, 2, 17, 17, 10, 19)

println(lst.aggregate(0)(add, add))
	0+14=14
	14+7=21
	21+8=29
	29+19=48
	48+12=60
	60+2=62
	62+17=79
	79+17=96
	96+10=106
	106+19=125
	125

println(lst.par.aggregate(0)(add, add))
	0+14=14
	0+17=17
	0+7=7
	0+10=10
	10+19=29
	0+2=2
	17+29=46
	0+8=8
	0+19=19
	14+7=21
	0+12=12
	0+17=17
	19+12=31
	2+17=19
	8+31=39
	19+46=65
	21+39=60
	60+65=125
	125

andThen def f = f1 andThen f2 f1和f2只有一个参数，且类型相同，f1的输出是f2的输入，先调用f1再调用f2

val add = (x:Int)=>{
  var z= x+3
  println(s"$x+3=$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

var a3 = Array.range(1,5)
var a4 = Array(1,2,2,4)
println(a3.andThen(x => {
  if (x % 3 == 0) "match"
}))--<function1>

val pf:PartialFunction[Int,Boolean] = (x:Int)=>{
  x match {
    case x if x%3==0 =>true
    case x => false
  }
}
println(pf(2))--结果为false


val pf:PartialFunction[Int,String] = (x:Int)=>{
  x match {
    case x if x%3==0 =>"Three"
    case x if x%7==0 =>"seven"
    case x =>"NULL"
  }
}
println(pf(4))---NULL

    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(3))---Some(Three)

  val pf:PartialFunction[Int,Option[Array[String]]] = (x:Int)=>{
  x match {
    case x if x%3==0 =>Some(Array("Three","abc"))
    case x if x%7==0 =>Some(Array("seven"))
    case x =>None
  }
}
    pf(3).get.foreach(println)--Three
								abc



  var op = Some("Three","abc","def")
  println(op)--Some((Three,abc,def))
  println(op.get)--(Three,abc,def)
  println(op.get._1)--Three
  op.get.productIterator.foreach(println)--Three
											abc
											def


  var ob = Some(Array("Three","abc","def"))
  ob.get.foreach(println)--Three
						   abc
						   def

copyToArray (Array [ ,deststartPos[, destLen] ] ) -------

	#将集合中的元素从0开始，拷贝到参数1数组从startPos开始长度为len的数组中

copyToBuffer(Buffer)将集合中的所有元素拷贝至参数Buffer中

endsWith 一个集合是否以一个有序的集合结尾的

scala> arr
res5: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> arr.endsWithArray(13,14,15)
res6: Boolean = true

startWith 一个集合是否以一个有序的集合结尾的

scala> arr.startsWithArray(1,2,3)
res8: Boolean = true

contains 一个集合是否包含一个元素

scala> arr.contains(2)
res10: Boolean = true

containsSlice 一个集合是否包含一个有序的集合

scala> arr.containsSliceArray(1,2,3)
res12: Boolean = true

scala> arr.containsSliceArray(1,3,3)
res13: Boolean = false

filter 删选一个集合中符合条件的元素

scala> arr.filter(_%2)==0
res14: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14)

filterNot 删选一个集合中符合条件剩下的元素

scala> arr
res15: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> arr.filterNot(_%2)==0
res16: Array[Int] = Array(1, 3, 5, 7, 9, 11, 13, 15)

find 查找集合中第一个符合条件的元素

scala> res16.find(_>10)
res17: Option[Int] = Some(11)

scala> res16.find(_>15)
res18: Option[Int] = None

flatten 把二元的数组拉平成一元数组

scala> var a2 = Array(Array(1,3,5),Array(4,6,8))
a2: Array[Array[Int]] = Array(Array(1, 3, 5), Array(4, 6, 8))

scala> a2.flatten
res19: Array[Int] = Array(1, 3, 5, 4, 6, 8)

scala> a2.flatten.mapx=>ifx%2==0 “even” else “odd”,1
res20: Array[String, Int] = Arrayodd,1, odd,1, odd,1, even,1, even,1, even,1

scala> a2.flatMapx=>x.mapx=>x,1
res21: Array[Int, Int] = Array1,1, 3,1, 5,1, 4,1, 6,1, 8,1

scala> a2.flatMapx=>x.mapx=>ifx%2==0"even" else “odd”,1
res24: Array[String, Int] = Arrayodd,1, odd,1, odd,1, even,1, even,1, even,1

scala> var arr = Array"1001",“henry”,“male”,100,“1002”,“pola”,“male”,130,“1003”,“ariel”,“male”,200
arr: Array[String, String, String, Int] = Array1001,henry,male,100, 1002,pola,male,130, 1003,ariel,male,200

scala> arr.mapx=>x._3,x._4
res25: Array[String, Int] = Arraymale,100, male,130, male,200

val add = x:Int,y:Int=>{
val z = x+y
printlns"$x+$y=$z"
z
}
  var arr = Array13,9,6,7,8,4,11
  arr.par.fold0add
  
  
	0+6=6
	0+4=4
	0+8=8
	0+9=9
	0+13=13
	0+7=7
	0+11=11
	
	7+8=15
	9+6=15
	4+11=15
	13+15=28
	
	15+15=30
	28+30=58

forall(条件) 集合中所有元素是否都满足条件，满足的话返回true

scala> var arr = Array1,2,3,4,5,6,7,8,9
arr: Array[Int] = Array1, 2, 3, 4, 5, 6, 7, 8, 9

scala> arr.forall(_.isInstanceOf[Int])
res1: Boolean = true

scala> arr.forall(_%2==0)
res2: Boolean = false

foreach 遍历元素

scala> arr.foreachprintln
1
2
3
4
5
6
7
8
9

scala> arr.foreachx=>prints" $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dotseachx=>{prints"$ x,"}
1,2,3,4,5,6,7,8,9,
scala> arr.foreachx=>prints"$x,"
1,2,3,4,5,6,7,8,9,

head 集合中的第一个元素

last 集合中的最后一个元素

scala> arr.head
res9: Int = 1

scala> arr.last
res10: Int = 9

headOption 集合中的第一个元素,集合为空返回None

lastOption 集合中的最后一个元素，集合为空返回None

scala> arr.headOption
res16: Option[Int] = Some1
arr.lastOption

scala> arr.lastOption
res2: Option[Int] = Some9

scala> var a2:Array[Int] = Array
a2: Array[Int] = Array

scala> a2.headOption
res17: Option[Int] = None

scala> a2.lastOption
res3: Option[Int] = None

tail 集合中的除了第一个元素剩下的元素集合

init 集合中的除了最后一个元素剩下的元素集合

scala> arr.tail
res11: Array[Int] = Array2, 3, 4, 5, 6, 7, 8, 9

scala> arr.init
res12: Array[Int] = Array1, 2, 3, 4, 5, 6, 7, 8

inits 对序列进行init去尾迭代

tails 对序列进行tail去头迭代

scala> arr.inits.foreachx=>{x.foreachprint;println}
123456789
12345678
1234567
123456
12345
1234
123
12
1

scala> arr.tails.foreachx=>{x.foreachprint;println}
123456789
23456789
3456789
456789
56789
6789
789
89
9

indexOf(value) 返回元素在集合中的下标

indexOf(value,pos) 返回元素在集合中从指定pos位置开始的下标，若不存在返回-1

scala> arr.indexOf(5)
res18: Int = 4

scala> arr.indexOf(5,4)
res19: Int = 4

scala> arr.indexOf(5,8)
res20: Int = -1

indexOfSlice 返回集合中子序列所在的下标，不存在返回-1

scala> arr.indexOfSliceArray(3,4)
res21: Int = 2

scala> arr
res22: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr.indexOfSliceArray(3,5)
res23: Int = -1

indexWhere(条件) 返回集合中第一个满足条件的元素下标，不存在返回-1

lastIndexOf(value) 返回元素最后一次出现在集合中的下标，不存在返回-1

lastIndexWhere(条件) 返回集合中满足条件的元素最后一次出现的下标，不存在返回-1

scala> arr.indexWhere(_>6)
res24: Int = 6

scala> var a3 = Array(1,2,3,4,5,6,6,7,7,7,8)
a3: Array[Int] = Array(1, 2, 3, 4, 5, 6, 6, 7, 7, 7, 8)

scala> a3.lastIndexOf(7)
res4: Int = 9

scala> a3.lastIndexWhere(_>6)
res26: Int = 10

indices 返回集合的下标集合

scala> arr.indices
res27: scala.collection.immutable.Range = Range 0 until 9

scala> arr.indices.foreach(print)
012345678

isDefinedAt 集合是否包含索引下标越界返回false

scala> arr.isDefinedAt(0)
res29: Boolean = true

scala> arr.isDefinedAt(9)
res30: Boolean = false

isEmpty 集合是否为空

nonEmpty 集合是否不为空

scala> arr.isEmpty
res31: Boolean = false

scala> arr.nonEmpty
res32: Boolean = true

isTraversableAgain 是否可以重复遍历集合可以返回true，迭代器不可以返回false

scala> arr.isTraversableAgain
res33: Boolean = true

scala> arr.toIterator.isTraversableAgain
res34: Boolean = false

length <=> size 返回序列中元素的个数

scala> arr
res9: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr.length
res7: Int = 9

scala> arr.size
res8: Int = 9

lengthCompare（int）返回集合长度-int的差值

scala> arr.lengthCompare(10)
res35: Int = -1

scala> arr.lengthCompare(9)
res36: Int = 0

max 返回集合中最大值

min 返回集合中最小值

scala> arr.max
res37: Int = 9

scala> arr.min
res38: Int = 1

maxBy(条件) 返回集合中【满足】条件的第一个值

minBy(条件) 返回集合中【不】满足条件的第一个值

scala> arr
res9: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr.maxBy(_<5)
res39: Int = 1

scala> arr.maxBy(_>5)
res40: Int = 6

scala> arr.minBy(_<5)
res41: Int = 5

scala> arr.minBy(_>5)
res42: Int = 1

mkstring 把集合变成字符串

mkstring(sepStr) 把集合中的元素按指定的字符sepStr,连接变成字符串

mkstring(startStr,sepStr,endStr) 把集合中的元素以startStr开始，sepStr连接各元素，endStr结束,来拼接成字符串

scala> arr.mkString
res11: String = 123456789

scala> arr.mkString("-")
res12: String = 1-2-3-4-5-6-7-8-9

scala> arr.mkString("*","_","#")
res13: String = *1_2_3_4_5_6_7_8_9#

padTo(len,e) 以指定元素e来填充集合的右边，直至集合的个数达到len,若len小于集合长度则不填充

scala> arr.padTo(20,"_")
res45: Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, _, _, _, _, _, _, _, _, _, _, _)

scala> arr.padTo(5,"_")
res14: Array[Any] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

par返回一个并行序列ParArray[T] ,内容不可更改,相当于hashcode partitioner,便于多线程执行

partition(条件) 将序列拆成满足条件和不满足条件的两个序列XxxBufferArrayBuffer/ListBuffer

scala> arr.partition(_%2==0)
res46: Array[Int], Array[Int] = Array(2, 4, 6, 8),Array(1, 3, 5, 7, 9)

patch(startPos,Seq,num) 把序列中从startPos【包含】开始num【0表示不删除元素】个元素替换为Seq序列【可以为空】

scala> arr.patch(2,Array(‘a’,‘b’),0)
res47: Array[AnyVal] = Array(1, 2, a, b, 3, 4, 5, 6, 7, 8, 9)

scala> arr.patch(2,Array(‘a’,‘b’),1)
res48: Array[AnyVal] = Array(1, 2, a, b, 4, 5, 6, 7, 8, 9)

scala> var i:Array[Int]=Array()
i: Array[Int] = Array()

scala> arr.patch(2,i,2)
res49: Array[Int] = Array(1, 2, 5, 6, 7, 8, 9)

prefixLength(条件返回集合中满足条件的元素数量

scala> var lst = Array(25,75,170,179,1,58,85,155)
lst: Array[Int] = Array(25, 75, 170, 179, 1, 58, 85, 155)

scala> lst.prefixLength(_<100)
res50: Int = 2

scala> lst.prefixLength(_>100)
res51: Int = 0

product 返回集合中所有元素的乘积

scala> arr.product
res52: Int = 362880

reduce 累加

fold

reduceLeft

reduceRight

reduceOption

reduceLeftOption

reduceRightOption

scala> arr.reduce(+)
res53: Int = 45

scala> arr.reduce((x,y)=>{var z=x+y;printlns" $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
res54: Int = 45

scala> arr.fold(0)(+)
res56: Int = 45

scala> arr.reduceLeft((x,y)=>{var z=x+y;printlns" $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
res58: Int = 45

scala> arr.reduceRight((x,y)=>{var z=x+y;printlns" $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
res59: Int = 45

scala> arr.reduceOption(x,y=>{var z=x+y;printlns" $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
res60: Option[Int] = Some(45)

scala> arr.reduceLeftOption(x,y=>{var z=x+y;printlns" $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
res62: Option[Int] = Some45

scala> arr.reduceRightOption(x,y=>{var z=x+y;printlns" $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
res63: Option[Int] = Some(45)

reverse 反转序列

reverseIterator 反向迭代器

scala> arr.reverse
res64: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)

scala> arr.reverseIterator
res65: Iterator[Int] =

scala> res65.foreach(print)
987654321

reverseMap 反向map

map

scala> arr.map(x=>{printlnx;x})
1
2
3
4
5
6
7
8
9
res67: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr.reverseMap(x=>{printlnx;x})
9
8
7
6
5
4
3
2
1
res69: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)

runwith[u] f:scala.Function1[B,0]=>scala.Function1[A,scala.Boolean]-----

#调用偏函数
val 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
arr. runwith(x)=>x match {
	case x if x%2==0 => x
}17

var arr = Array(“henry”,“male”,“nanjing”,28,12000,“pola”,“female”,“shanghai”,22,18000,“ariel”,“female”,“nanjing”,20,22000,“angela”,“male”,“nanjing”,28,12000,“xiaoming”,“female”,“shanghai”,25,19000)

#不同性别平均薪资
arr.grouped(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}"))

scala> var arr = Array.range(1,10)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> var arr2 = Array.range(1,10)
arr2: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scan(initValue)((x,y)=>z) 对集合中所有元素进行二元计算(+ - * /)

scanRight (initValue)((x,y)=>z)对集合中所有元素从右到左进行二元计算

scala> arr2
res91: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr2.scan(0)(+)
res97: Array[Int] = Array(0, 1, 3, 6, 10, 15, 21, 28, 36, 45)

scala> arr2.scan(0)(-)
res93: Array[Int] = Array(0, -1, -3, -6, -10, -15, -21, -28, -36, -45)

scala> arr2.scan(1)(*)
res96: Array[Int] = Array(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880)

scala> arr2.scan(20)(/)
res95: Array[Int] = Array(20, 20, 10, 3, 0, 0, 0, 0, 0, 0)

scala> arr.scanRight(0)(+)
res3: Array[Int] = Array(45, 44, 42, 39, 35, 30, 24, 17, 9, 0)

segmentLength(条件，pos) 返回集合中从pos位置开始符合条件的元素个数，如第一个就不满足则返回0

scala> arr.segmentLength(_>4,0)
res6: Int = 0

res3: Array[Int] = Array(45, 44, 42, 39, 35, 30, 24, 17, 9, 0)

scala> res3.segmentLength(_>4,5)
res8: Int = 4

seq 产生一个特殊集合WrappedArray

scala> arr.seq
res9: scala.collection.mutable.IndexedSeq[Int] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)

#slice【fromIndex,endIndex) 前包后不包
#view【fromIndex,endIndex) 前包后不包
scala> arr
res11: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> arr.slice(4,8)
res10: Array[Int] = Array(5, 6, 7, 8)

scala> arr.view(4,8)
res12: scala.collection.mutable.IndexedSeqView[Int,Array[Int]] = SeqViewS(…)

scala> res12(0)
res13: Int = 5

scala> res12(1)
res14: Int = 6

scala> res12(2)
res15: Int = 7

scala> res12(3)
res16: Int = 8

scala> res12(4)
java.lang.IndexOutOfBoundsException: 4
at scala.collection.SeqViewLike $S l i c e d . a p p l y (S e q V i e w L i k e . s c a l a : 62) a t s c a l a . c o l l e c t i o n . S e q V i e w L i k e$ Sliced.apply $(S e q V i e w L i k e . s c a l a : 60) a t s c a l a . c o l l e c t i o n . m u t a b l e . I n d e x e d S e q V i e w$ $anon$2.apply(IndexedSeqView.scala:81)
… 28 elided

scala> res12.foreach(print)
5678

sliding(size[,step]) 在集合中依次取size个元素，以step大小的步伐滑动，即每组对应位置元素的下标差值为step(不写默认为1)

scala> arr.sliding(5)
res19: Iterator[Array[Int]] =

scala> arr.sliding(5).toArray
res20: Array[Array[Int]] = Array(Array(1, 2, 3, 4, 5), Array(2, 3, 4, 5, 6), Array(3, 4, 5, 6, 7), Array(4, 5, 6, 7, 8), Array(5, 6, 7, 8, 9))

sorted 只能对集合升序排序

sortWith 可对集合升序(<)或者降序(>)排序

sortBy 可对集合升序(x=>x)或者降序(x=>(-x))排序

scala> var at = Array(8,5,3,2,1,4,7,9,6)
at: Array[Int] = Array(8, 5, 3, 2, 1, 4, 7, 9, 6)

scala> at.sorted
res28: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> at.sortWith(>)
res29: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)

scala> at.sortWith(<)
res30: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> at.sortBy(x=>x)
res31: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> at.sortBy(x=>(-x))
res33: Array[Int] = Array(9, 8, 7, 6, 5, 4, 3, 2, 1)

span(条件) 对集合中第一个满足条件到第一个不满足条件的分为一个数组，剩余的为一数组，如第一个元素就不满足条件，则第一个数组为空

scala> at
res34: Array[Int] = Array(8, 5, 3, 2, 1, 4, 7, 9, 6)

scala> at.span(_>=5)
res35: (Array[Int], Array[Int]) = (Array(8, 5),Array(3, 2, 1, 4, 7, 9, 6))

scala> at.span(_>8)
res36: (Array[Int], Array[Int]) = (Array(),Array(8, 5, 3, 2, 1, 4, 7, 9, 6))

splitAt(pos) 在指定位置把数组拆成两个，pos位置的元素在第二个数组

scala> at.splitAt(3)
res37: (Array[Int], Array[Int]) = (Array(8, 5, 3),Array(2, 1, 4, 7, 9, 6))

sum 对集合元素求和

scala> at.sum
res38: Int = 45

scala> at
res39: Array[Int] = Array(8, 5, 3, 2, 1, 4, 7, 9, 6)

stringPrefix 返回集合toString后的前缀

scala> at.stringPrefix
res40: String = [I

scala> at.toString
res41: String = [I@5bb9ce5b

subSequence【fromIndex,endIndex) 返回指定范围【前包后不包)的【字符】序列,若endIndex超出数组长度，也不会报错

scala> Array(‘a’,‘b’,‘c’,‘d’,‘e’)
res43: Array[Char] = Array(a, b, c, d, e)

scala> res43.subSequence(1,3)
res44: CharSequence = bc

scala> res43.subSequence(1,8)
res45: CharSequence = bcde

take(n) 返回集合中从左到右n个元素

takeRight(n) 返回集合中从右到左n个元素

takeWhile(条件)返回集合中从左到右满足条件直到第一个不满足条件的元素，如第一个就不满足条件则返回空集合

scala> at
res50: Array[Int] = Array(8, 5, 3, 2, 1, 4, 7, 9, 6)

scala> at.take(3)
res46: Array[Int] = Array(8, 5, 3)

scala> arr.take(3)
res47: Array[Any] = Array(henry, male, nanjing)

scala> at.takeRight(3)
res48: Array[Int] = Array(7, 9, 6)

scala> at.takeWhile(_>4)
res49: Array[Int] = Array(8, 5)

scala> at.takeWhile(_>8)
res51: Array[Int] = Array()

toSet 转化为Set类型(去重，无序)

toMap 转化为Map类型

toStream 转化为Stream类型，可以用foreach遍历出来

scala> Array(1,2,1,3,4,2,5)
res52: Array[Int] = Array(1, 2, 1, 3, 4, 2, 5)

scala> res52.toSet
res53: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala> res52.distinct
res54: Array[Int] = Array(1, 2, 3, 4, 5)

scala> res52.map((_,1)).toMap
res55: scala.collection.immutable.Map[Int,Int] = Map(5 -> 1, 1 -> 1, 2 -> 1, 3 -> 1, 4 -> 1)

scala> at.toStream
res56: scala.collection.immutable.Stream[Int] = Stream(8, ?)

scala> res56.head
res57: Int = 8

scala> res56.tail
res59: scala.collection.immutable.Stream[Int] = Stream(5, ?)

scala> res56.foreach(println)
8
5
3
2
1
4
7
9
6

scala> res56
res61: scala.collection.immutable.Stream[Int] = Stream(8, 5, 3, 2, 1, 4, 7, 9, 6)

transform(运算) 集合元素经过运算转换为指定元素【原集合元素变化】，输出的类型还是要和原本集合的数据类型一致，不一致的话需要转化一下

transpose 矩阵转置(行转列，列转行)

scala> at
res62: Array[Int] = Array(8, 5, 3, 2, 1, 4, 7, 9, 6)

scala> at.sorted.transform(Math.pow(_,2).toInt)
res63: scala.collection.mutable.WrappedArray[Int] = WrappedArray(1, 4, 9, 16, 25, 36, 49, 64, 81)

scala> at.transform(Math.pow(_,2).toInt)
res64: scala.collection.mutable.WrappedArray[Int] = WrappedArray(64, 25, 9, 4, 1, 16, 49, 81, 36)

scala> var d2a = Array(Array(1,2,3),Array(4,5,6),Array(7,
8,9))
d2a: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))

scala> d2a.transpose
res65: Array[Array[Int]] = Array(Array(1, 4, 7), Array(2, 5, 8), Array(3, 6, 9))

union <=> ++ 合并两个集合,原本的集合不会改变

++=：：后面的接的是可变集合，该集合的值是会改变的

scala> arr2
res66: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> at.union(arr2)
res67: Array[Int] = Array(64, 25, 9, 4, 1, 16, 49, 81, 36, 1, 2, 3, 4, 5, 6, 7, 8, 9)

unzip 两个元素构成的元祖数组的第一和第二个元素分别组成两个数组并封装成元祖

unzip3 三个元素构成的元祖数组封装成分别由三个元素构成数组的元祖

scala> var arr = Array((“henry”,1),(“pola”,2),(“ariel”,3))
arr: Array[(String, Int)] = Array((henry,1), (pola,2), (ariel,3))

scala> arr.unzip
res68: (Array[String], Array[Int]) = (Array(henry, pola, ariel),Array(1, 2, 3))

scala> var arr3 = Array((“henry”,“male”,1),(“pola”,“female”,2),(“ariel”,“female”,3))
arr3: Array[(String, String, Int)] = Array((henry,male,1), (pola,female,2), (ariel,female,3))

scala> arr3.unzip3
res70: (Array[String], Array[String], Array[Int]) = (Array(henry, pola, ariel),Array(male, female, female),Array(1, 2, 3))

zip 两个序列的元素，同一位置上的元素组成元祖数组，若长度不一致，则以最短的序列元素匹配完为止

zipAll(seq,forEle,backEle) 两个序列的元素，同一位置上的元素组成元祖数组，若长度不一致，则forEle补前面的序列，backEle补后面的序列

zipWithIndex 序列的元素和小表组成元祖数组

scala> var a2 = Array(‘a’,‘b’,‘c’)
a2: Array[Char] = Array(a, b, c)

scala> var a3 = Array(1,2,3)
a3: Array[Int] = Array(1, 2, 3)

scala> a2.zip(a3)
res80: Array[(Char, Int)] = Array((a,1), (b,2), (c,3))

scala> a3.zip(a2)
res81: Array[(Int, Char)] = Array((1,a), (2,b), (3,c))

scala> a1
res102: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)

scala> a2
res103: Array[Char] = Array(a, b, c)

scala> a1.zip(a2)
res104: Array[(Int, Char)] = Array((2,a), (4,b), (6,c))

scala> a2.zip(a1)
res105: Array[(Char, Int)] = Array((a,2), (b,4), (c,6))

scala> var a4 = Array(‘a’,‘b’,‘c’,‘d’)
a4: Array[Char] = Array(a, b, c, d)

scala> a4.zipAll(a3,‘N’,0)
res83: Array[(Char, Int)] = Array((a,1), (b,2), (c,3), (d,0))

scala> a3.zipAll(a4,‘N’,0)
res108: Array[(AnyVal, AnyVal)] = Array((1,a), (2,b), (3,c), (N,d))

scala> a2
res87: Array[Char] = Array(a, b, c)

scala> a2.zipWithIndex
res88: Array[(Char, Int)] = Array((a,0), (b,1), (c,2))

update(pos,value) 将数组中指定下标pos位置的元素改为value，原数组改变

updated(pos,value) 将数组中指定下标pos位置的元素改为value，原数组【不】改变

scala> at
res71: Array[Int] = Array(64, 25, 9, 4, 1, 16, 49, 81, 36)

scala> at.update(2,3)

scala> at
res74: Array[Int] = Array(64, 25, 3, 4, 1, 16, 49, 81, 36)

scala> at.updated(2,9)
res75: Array[Int] = Array(64, 25, 9, 4, 1, 16, 49, 81, 36)

scala> at
res76: Array[Int] = Array(64, 25, 3, 4, 1, 16, 49, 81, 36)

filter(条件) 返回集合中【所有】符合条件的元素

withFilter(条件) 功能类似filter，返回类型不同，要用foreach遍历，返回集合中【所有】符合条件的元素

scala> at.withFilter(_>4)
res77: scala.collection.generic.FilterMonadic[Int,Array[Int]] = scala.collection.TraversableLike$WithFilter@7270e44f

scala> at.filter(_>4)
res78: Array[Int] = Array(64, 25, 16, 49, 81, 36)

scala> at.withFilter(_>4).foreach(println)
64
25
16
49
81
36

dontlikerabbit

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
scala中函数算子示例详解

scala> var a1 = Array(“a”,“b”,“c”)a1: Array[String] = Array(a, b, c)scala> var a2 =Array(“1”,“2”,“3”)a2: Array[String] = Array(1, 2, 3)++ 和++：两个集合合并，基本上没有区别，:后指向类型scala> a1++a2res0: Array[String] = Array(a, b, c, 1, 2, 3)scala> a1++:a2r
复制链接

扫一扫