scala常用算子

scala常用算子

提取元素

val v:T = arr.head #Array(1, 2, 3).head =>1 提取数组第一个元素
val v:Option[T] = arr.headOption #Array(1, 2, 3).headOption => Some(1)
val v:T = arr.last # Array(1, 2, 3).last =>3 提取数组最后一个元素
val v:T = arr(index:Int) #println(arr1(2)) =>3
val v:T = arr.apply(index:Int) # arr1.apply(2) =>11
#arr1.applyOrElse(9, (ix: Int) => ix2) =>18
#arr1.applyOrElse(2, (ix: Int) => ix2) =>3
#提取指定下标位置的元素，若越界则返回【参数2函数】返回值
val v:T = arr.applyOrElse(index:Int)
val arr:[Array[T]] = arr.take(size:Int) #arr1.take(2)=>1,3 =>从左边取size个元素
val arr:[Array[T]] = arr.takeRight(size:Int)#arr1.takeRight(2)=> 9,7 =>从右边取size个元素
val arr:[Array[T]] = arr.takeWhile(f:T=>Boolean) #arr1.takeWhile(%2==1) =>1,3,11,9,7 =>从下标0开始取，从第一个满足条件开始到第一个不满足条件结束
val arr:[Array[T]] = arr.filter(f:T=>Boolean) # arr1.filter(%2 == 0) =>提取集合中所有满足条件的元素
val arr:[Array[T]] = arr.filterNot(f:T=>Boolean) # arr1.filterNot(%2 == 0)=> 提取集合中所有不满足条件的元素
#偏函数
val arr1 = Array(1,2,3,5,4,2,5)
val arr2 = ArrayBuffer(3,5,6)
val pf:PartialFunction[Int,Int] = (x:Int) =>x match{
case x if(x%21) =>x
}
val arr:[Array[T]] = arr.collect(ParialFunction[T,B]:T=>B) #1,3,5,5 arr1.collect(pf) =>提取集合中所有满足参数偏函数条件元素
val arr:[Array[T]] = arr.collectFirst(ParialFunction[T,B]:T=>B) #arr1.collectFirst({case x if(x%21) =>x})=>提取集合中第一个满足参数偏函数条件Option[元素]
val arr:[Array[T]] = arr.find(f:T=>Boolean) #arr1.find(>77) =>提取集合中第一个满足参数偏函数条件元素
val arr:[Array[T]] = arr.slice(from:Int,until:Int) #arr1.slice(1,4) =>提取从from(inclusive)至until(exclusive)之间的所有元素
val arr:Array[Int] = arr.init #arr1.init =>1,2,3,5,4,2 =>提取除了最后一个元素之外的所有元素
val arr:Iterator[mutable.WrappedArray[T]] = arr.inits => 递归提取除了最后一个元素之外的所有元素，并封装成迭代器返回
val arr:Array[Int] = arr.tail # arr1.tail.foreach(println) => 2,3,5,4,2,5 => 提取除了第一个元素之外的所有元素
val arr:Iterator[mutable.WrappedArray[T]] = arr.tails # arr1.inits.foreach(line=>println(line.mkString(","))) =>递归提取除了最后一个元素之外的所有元素，并封装成迭代器返回
val f : Int =>Option[Int] = Array().lift
println(f(0)) =>返回根据下标气体去(Option[T]) 数组元素的函数
//返回根据参数偏函数规则提取数组元素的偏函数
val f:ParialFunction[T,B] = arr.orElse(f:ParialFunction[T,B])
#自定义根据提取或处理集合元素规则的偏函数
val pf:PartialFunction[Int,Any] = arr.orElse({
case ix if(ix>=0 && ix<arr.length) => Some(arr(ix))
case _ => None
})
println(pf(8))

修改操作

arr.update(index:Int,newV:T) #arr1.update(1, 2) =>修改执行下标位置元素值为newV
val arr:Array[T] = arr.updated(index:Int,newV:T) # arr1.updated(1,2).foreach(print) =>修改执行下标位置元素值为newV，并经修改后的之歌数组返回
#并集
val newArr = arr ++ | union sub
val arr3 = arr1 union(++) arr2
arr3.foreach(print)
#交集
val newArr = arr itersect sub
#差集
val newArr = arr diff sub
val arr3 = arr1 intersect arr2
arr3.foreach(print)
#尾部追加
val newArr = arr:+ elem
val arr3 = arr1:+ 3
arr3.foreach(print)
#头部追加
val newArr = elem +: arr
val arr3 = 3+: arr1
arr3.foreach(print)
#头删除n个元素
val newArr = arr.drop(n:Int)
arr1.drop(3).foreach(println)
#尾删除n个元素
val newArr = arr.dropRight(n:Int)
arr1.dropRight(3).foreach(println)
#删除符合条件的元素，直到第一个不符合条件的元素，如果第一个就不符合条件就不删除
val newArr = arr.dropWhile(f:Int=>Boolean)
arr1.dropWhile(_>0).foreach(println)
//将源数组中从from(inclusive)开始replaceLen个元素替换成GenSep
//sun为空，则为删除源数组中从from（inclusive)开始的replaceLenge 元素
val newArr = arr.patch(from:Int,sub:GenSeq,replaceLen:Int)
arr1.patch(2,“1234”,6).foreach(print) => 321234

逐个迭代处理

val tarr:Array[B] = arr.map(f:T=>B)
var tarr:Array[B] = darr.transform(f:T=>B)
val tarr:Array[B] = darr.reverseMap(f:T=>B)
#一个flatten一次降一个维度
val tarr:Array[T] = darr.flatten
arr2.flatten.flatten.foreach(println)
#flatMap = map + flatten 即先对集合中的每个元素进行map，
#再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten
var tarr:Array[B] = darr.flatMap(f:T=>B)

分组

val parr:ParArray[T] = arr.par
#按条件分组
var arr:(Array[T],Array[T]) = arr.partition(f:T=>Boolean)
val pf = arr1.partition(_%20)//余2等于等于0(双等于没显示)
pf._1.foreach(println)
println("==============")
pf.2.foreach(println)
#每Int一组进行分组
var iter: Iterator [Array[T]] = arr .grouped(size:Int) => size : item size per group => sliding (n,n)
arr1.grouped(2).foreach(arr=>println(arr.mkString(",")))
#以每三个一组，步长为2分组
var iter:Iterator [Array[T]] = arr.sliding(size:Int[,tep: Int default 1])
arr1.sliding(3,2).foreach(arr=>println(arr.mkString(",")))
#按条件分组，输出是map
var arr5 = Array(1,2,3,11,9,7)
arr5.groupBy(%20).foreach(x=>println(s"KaTeX parse error: Undefined control sequence: \t at position 7: {x._1}\̲t̲{x._2.mkString(",")}"))
var iter: [(K,Array[T])] = arr.groupBy (key:K)

聚合

val value:B = arr.reduce (f:(T,T)=>B)
1）println(arr1.reduce(_ + ))
2）val add = (x:Int,y:Int) =>{
println(s"$x+${y}=KaTeX parse error: Expected 'EOF', got '}' at position 25: … x+y }̲ println(arr1…{x}+$y=${x+y}")
x+y
}
println(arr1.foldRight(3)(add))
println(arr1.:\ (3)(add))
#从左边迭代聚合
val value:B = arr.foldLeft(f:(T,T)=>B) => / :
#从左边迭代聚合
val value:B = arr.foldRight(initval:T)(f:(T,T)=>B) => :
#从左边迭代聚合 返回值是数组
val value:Array[B] = arr.scan(initval:T)(f:(T,T)=>B)
val value:Array[B] = arr.scanLeft(initval:T)(f:(T,T)=>B)
val value:Array[B] = arr.scanRight(initval:T)(f:(T,T)=>B)
#val value:B = arr.par.aggregate(initV:B)(map:(T,T)=>B,reduce:(B,B)=>B) =>速度快(并行)
#求和 println(arr1.sum)
val value:T = arr.sum
#计数 println(arr1.count(%2==1))
val value: Int = arr.count(f:T=> Boolean)
#最小值println(arr1.min)
val value:T = arr.min;
#最大值println(arr1.max)
val value:T = arr.max;
var arr3 = Array((“henry”,“male”,22),(“hrose”,“female”,33),(“arriel”,“male”,44),(“pola”,“male”,66),(“jack”,“female”,77))
println(arr3.maxBy(.3))
println(arr3.minBy(.3))
val value:T = arr.minBy(.?) => T:Tuple | Class
val value:T = arr.minBy(.?) => T:Tuple | Class

验证

#验证集合是否为空
val bool :Boolean = arr. isEmpty
#验证集合是否为非空集合
val bool :Boolean = arr.nonEmpty
#集合中是否存在符合参数函数条件的元素
println(arr1.exists(x=>x>20))
val bool :Boolean = arr.exists (p: Int=>Boolean)
#集合中是否包含参数元素的值
println(arr1.contains(5))
val bool :Boolean = arr.contains (elem: Int)
#集合中是否包含完整的参数序列 顺序要相同
val arr1 = Array(3,2,3,5,4,2,5)
println(arr1.containsSlice(Array(3,3))) =>false
println(arr1.containsSlice(Array(3,2))) =>true
val bool :Boolean = arr.containsSlice (sub: GenSeq)
#集合中是否所有元素都符合参数条件
println(arr1.forall(x=>x<=5)) => true (所有参数都大于等于5)
val bool :Boolean = arr.forall (p:Int=>Boolean)
#集合中是否所有参数按照索引顺序和参数序列符合参数函数特征
println(arr1.corresponds(Array(3,2,3))(_ == _))
val bool :Boolean = arr.corresponds (sub :GenSeq) (p: Int=>Boolean)
#集合和子集合是否具有相同的元素
println(Array(1, 2, 3).sameElements(Array(1, 2, 3)))
val bool :Boolean = arr.sameElements (sub: GenSeq)
#集合是否以参数子序列开头
println(arr1.startsWith(Array(3,2)))
val bool :Boolean = arr.startswith (sub:GenSeq)
#集合是否以参数子序列结尾
println(arr1.endsWith(Array(5,6,2)))
val bool :Boolean = arr.endsWith (sub : GenSeq)

大小

val arr:Array[Int] = Array(8,9,11,22,33,45,22,33,44)
#数组的长度
val len: Int = arr.length| size
#集合中从左侧开始连续满足参数函数条件的元素数量，如第一个元素就不满足则返回0
println(arr.prefixLength(_ > 30))
val len: Int = arr.prefixLength (f: Int=> Boolean)
#从参数2位置开始(包含)连续满足参数函数条件的元素数量
println(arr.segmentLength(_ < 30,0))
val len: Int = arr.segmentLength(f: Int=>Boolean， pos: Int)
#返回数组长度和参数长度的差值 参数大于数组长度就是负值
println(arr.lengthCompare(44))
val dif:Int = arr.lengthCompare (len: Int)

转变

#copyToArray (arr:Array[T])
val copy = Array(0,0,0,0,0,0,0,0,0)
arr.copyToArray(copy)
#copyToBuffer (mutable. Buffer[T])
val buf:mutable.Buffer[Int] = mutable.Buffer()
arr.copyToBuffer(buf)
buf.foreach(println)
#toArray
val arr:Array[T] = arr. toArray
#toBuffer
val arr:mutable.Buffer[T] = arr. toBuffer
#获取集合副本
val arr:Array[T] = arr.array
val arr:Array[T] = arr.clone //获取集合副本
val arr :mutable. Indexedseq[T] = arr. deep //获取集合副本
val arr :mutable . WrappedArray[T] = arr.repr //获取集合副本
val arr :mutable. IndexedSeq[T] = arr. seq //获取集合副本
#键值映射 val arr:Map[K,V] = arr.toMap //键值映射Tuple2
val arr3 :Array[(String,String)] = Array((“henry”,“abc123”),(“hen”,“abc1234”),(“scala”,“abc223”))
val map:Map[String,String] = arr3.toMap
map.keys.foreach(println)
map.values.foreach(println)
println(map.contains(“he”))
println(map.apply(“hen”))
#toSet 去重
println(arr1.toSet.mkString(","))
val arr:Set[T] = arr. toSet //去重<=> distince
#toIterator
val ita1: Iterator[Int] = arr1.toIterator
println(ita1.mkString(","))
println("============")
ita1.foreach(println)
val arr: Iterator[T] = arr. toIterator //-次迭代
#toString
val stream : Stream[Int] = Array().toStream
println(stream.head)//报异常
println(if(stream.headOption.isEmpty) “None” else stream.head)
val arr:Stream[T] = arr. toStream //不定数量元素遍历( 懒加载)
#parTo 输出len个长度的数组 ，如果arr.size<len,则将多余的长度填充为参数2:elem
println(arr.padTo(11,9).mkString(","))
val arr:Array[T] = arr. padTo (len: Int,elem:T)
#将集合从左侧第-一个满足条件的元素开始至第一个不满足条件的元素结束作为一个数组
#剩余的元素作为另一个数组，将两者包装成元祖返回
val tp: (Array[Int], Array[Int]) = arr.span(_%20)
println(tp._1.mkString(","))
println(tp._2.mkString(","))
val tp2: (Array[T], Array[T]) = arr. span (f:T=>Boolean)
#将集合以参数作为临界点(参数下标放于后者)分割成两个数组，并包装成元组返回
val tp2: (Array[T] ,Array[T]) = arr. sp1itAt (index: Int)
arr.splitAt(5)._1.foreach(println)
#二维矩阵转置 行转列
val arr2d2 :Array [Array[T]] = arr2d1. transpose;
Array(Array(1,2,3),Array(4,5,6)).transpose.foreach(x=>println(x.mkString(",")))
#将两个集合每相同位置下标的两个元素组合成Tuple2,并将其包装成数组返回
#注意:如果两个集合长度不一致，则多余的长度将被忽略
val arr:Array((T,B)) = arr1[T] .zip(arr2[B] )
Array(“henry”,“pola”,“jack”)
.zip(Array(18,33,44))
.zip(Array(“male”,“female”,“male”))
.map(x=>(x._1._1,x._1.2,x.2))
.foreach(println)
#如果arrl.size>arr2.size:则元祖 2值 由thatElem作为默认值
#如果arr1.size<arr2.size:则元祖 1值由thisElem作为默认值
val arr:Array((T,B)) = arr1[T].zipA1l(arr2 [B],thisElem:T,thatElem:B)
Array(“henry”,“pola”,“jack”)
.zipAll(Array(19,20),22,33)
.zipAll(Array(“male”,“female”),“male”,“female”)
.foreach(println)
#将由Tuple2构成的数组中_1和_2单独抽离并分别包装成2个数组，并包装成由两个数组构成的元祖返回.
val uz: (Array[String], Array[Int]) = Array((“henry”,18),(“pola”,22),(“rose”,19)).unzip
println(uz.1.mkString(","))
println(uz.2.mkString(","))
var tp2:Tuple [Array[T] , Array[T]] = arr [Array [Tup1e2] ] . unzip
#将由Tup1e3构成的数组中 1、 2和 3单独抽离并分别包装成3个数组，并包装成由三个数组构成的元祖返回
var tp3:Tup1e3 [Array[T] , Array[T] ,Array[T]] = arr [Array [Tup1e3] ] . unzip3
#将集合每个元素及其对应的下标包装成Tuple2，并将所有Tuple包装成数组返回
var tp2:Array( (T, Int) ) = arr. zipWithIndex;
arr1.zipWithIndex.foreach(println)

顺序(排序)

#倒序副本
println(arr1.reverse.mkString(","))
val arr:Array[T] = arr. reverse
#倒序迭代器
println(arr1.reverseIterator.mkString(","))
val arr: Iterator[T] = arr. reverIterator
#升序
arr1.sorted.foreach(println)
println(arr1.sorted.mkString("<"))
val arr:Array[T] = arr. sorted
#x=>x升序x=> -x降序
println( arr1.sortBy(x=>x).mkString("<"))
println( arr1.sortBy(x=> -x).mkString(">"))
val arr:Array[T] = arr. sortBy(f:T=>T)
#符号控制升降序 _ <_ ：升序_ >： 降序
println(arr1.sortWith(<_).mkString(","))
val arr:Array[T] = arr. sortwith(f: (T1, T2)=>Boolean)

拼接字符串

#将集合元素拼接成字符串
var str:String = arr. addString (builder :StringBuilder[, sep:String])
val builder = new StringBuilder
val str : StringBuilder = arr1.addString(builder)
println(str)
builder.clear()
#
var str:String = arr. addstring (builder: stringBuilder, start:string, sep:string, end:String)
val str2:StringBuilder = arr1.addString(builder,"{",",","}")
println(str2)
#将集合元素拼接成字符串
println(arr1.mkString("<",",",">"))
var str:String = arr . mkString (sep: String) .
var str:String = arr.mkString (start:string, sep:string, end: String)

根据值取下标

#获取集合中元素从左向右第一个等于参数数值的下标
val ix:Int = arr.indexOf(v:T[, start: Int] )
println(arr1.indexOf(5))
#获取集合中从左向右第一个连续等于参数子序列值的首元素下标
val ix:Int = arr. indexofSlice (arr :GenSeq[, start:Int])
println(arr1.indexOfSlice(Array(5, 3, 7)))
#获取集合从左向右第一个符合参数函数条件值的下标
rintln(arr1.indexWhere(_ < 5))
val ix:Int = arr. indexOfWhere (f:T=>Boolean[, start: Int])
#以下从右向左执行
val ix:Int = arr. lastIndexOf (v:T[, start:Int])
println(arr1.lastIndexOf(5))
val ix:Int = arr. lastIndexOfSlice (arr: GenSeq[, start: Int])
println(arr1.lastIndexOfSlice(Array(3,7,5)))
println(arr1.lastIndexWhere(_ > 6))
val ix:Int = arr.lastIndexOfWhere (f:T=>Boolean[, start: Int])
println(arr1.lastIndexWhere(_ > 6))
#返回数组所有下标的序列
val ixs:Array[Int] = arr. indices
arr1.indices.foreach(println)