和大家分享一下Scala中对Array对象进行处理的一些常用算子的用法，附有自己给的一些简单的例子，有瑕疵之处敬请指出，共同学习。
提取元素
//用例
val v2020 = Array(186, 163, 172, 145, 178, 122, 135, 118, 156, 175, 128, 184)
val v2021 = Array(192, 188, 169, 155, 183, 120, 130, 122, 160, 177, 144, 167)
//获取首个元素
val v:T = arr.head
//v2020.headOption => Some(186)
val v:Option[T] = arr.headOption
//获取数组arr的最后一个元素
val v:T = arr.last
//lastOption,可以使用get取出里面的值
val v:Option[T] = arr.lastOption
//根据数组下标取值，输入的下标过界会报异常
val v:T = arr(index:Int)
//返回根据参数(偏函数规则)提取数组元素的偏函数
//value的参数值在数组下标范围以内的，相当于调用数组对应下标的值，超过数组下标，则调用偏函数对传入的参数进行逻辑处理
/*
val value: PartialFunction[Int, Int] = v2020.orElse({ case x if (x > 150) => x ;case _ => 150})
var count = 0
for (x <- v2020) {
v2020(count)=value(x)
count+=1
}
println(v2020.mkString(","))
*/
//val value1: PartialFunction[Int, Any] = v2020.orElse({ case x if (x < 0 || x >= v2020.size) => "outOfIndex" })
//value1(1)等于v2020(1) => 163
//value1(14) => outOfIndex
val f:PartialFunction[T,B] = arr.orElse(f:PartialFunction[T,B])
//根据数组下标取值，输入的下标过界会报异常
val v:T = arr.apply(index:Int)
//println(v2020.applyOrElse(3, {x:Int => "outOfIndex"})) => 145
//println(v2020.applyOrElse(12, {x:Int => "outOfIndex"})) => outOfIndex
//下标未越界，返回数组对应下标的值，下标越界，调用后面的函数并返回函数值
val v:T = arr.applyOrElse(index:Int,{x:Int=>"outOfIndex"})
//提取数组中前size个元素，当size值大于数组中实际元素个数时，提取数组所有元素，空数组不报异常
val arr1:[Array[T]] = arr.take(size:Int)
//提取数组中后size个元素
val arr1:[Array[T]] = arr.takeRight(size:Int)
//从第一个元素开始，提取满足条件的元素，至第一个不满足条件的元素止
val arr1:[Array[T]] = arr.takeWhile(f:T=>Boolean)
//从第一个元素开始，提取所有满足条件的元素，至最后一个元素止
val arr1:[Array[T]] = arr.filter(f:T=>Boolean)
//从第一个元素开始，提取所有不满足条件的元素，至最后一个元素止
val arr1:[Array[T]] = arr.filterNot(f:T=>Boolean)
//提取集合中满足参数（偏函数）条件的所有元素
//v2020.collect({case x if(x%2==0) => x})
val arr1:[Array[B]] = arr.collect(PartialFunction[T,B]:T=>B)
//提取集合中第一个满足参数（偏函数）条件的option[元素]
//arr.collectFirst({case x if(x>=10)=>x})
val v:T = arr.collectFirst(PartialFunction[T,B]:T=>B)
//集合中第一个满足条件的值，和collectFirst有相似之处
//arr.find(_>5)
val v:T = arr.find(f:T=>Boolean)
//截取从from(inclusive)至until(exclusive)之间的所有元素，from和until值越界不报错
val arr1:[Array[T]] = arr.slice(from:Int,until:Int)
// 返回包含除了最后一个元素之外的所有元素的数组（集合）
// println(v2020.init.mkString(",")) val init: Array[Int] = v2020.init
// 186,163,172,145,178,122,135,118,156,175,128
val arr1: Array[T] = arr.init
//递归提取集合中的元素，从全部元素的集合每次去除最后一个元素至只剩第一个元素的集合，并封装成迭代器返回
//val inits: Iterator[Array[Int]] = v2020.inits
//v2020.inits.foreach(x=>println(x.mkString(",")))
/*
186,163,172,145,178,122,135,118,156,175,128,184
186,163,172,145,178,122,135,118,156,175,128
186,163,172,145,178,122,135,118,156,175
186,163,172,145,178,122,135,118,156
186,163,172,145,178,122,135,118
186,163,172,145,178,122,135
186,163,172,145,178,122
186,163,172,145,178
186,163,172,145
186,163,172
186,163
186
*/
val it:Iterator[mutalbe.wrappedArray[T]] = arr.inits
//返回根据下标提取（Option[T]）数组元素的函数
/*
val lift: Int => Option[Int] = v2020.lift
val prf = (x:Int)=>{
lift(x) match {
case None => null
case _ => lift(x).get
}
}
def prt(x:Int) = {
lift(x) match {
case None => null
case _ => lift(x).get
}
}
prf(22)==lift(22).orNull==lift(22).getOrElse(null) => null
prt(1)==lift(1).orNull==lift(1).getOrElse(null) => 163
*/
//Option.orElse(Some(value)) 如果Option不为None返回Some否则返回参数的Some
val f:Int=>Option[T] = arr.lift
扩充、修改
// val unit: Unit = v2020.update(1, 333)
//修改下标index位置的元素为newValue，无返回值，index越界会报错
arr.update(index:Int,newValue:T)
//修改执行下标位置元素值为newv ,并将修改后的这个数组返回
//val ints: Array[Int] = v2020.updated(1, 333)
val arr:Array[T] = arr.updated(index:Int,newV:T)
//并集 val ints: Array[Int] = v2020 ++ v2021
//arr后面追加sub，存在一个新数组里
val newArr = arr ++|union sub
//交集 val ints1: Array[Int] = v2020 intersect v2021
//提取arr和sub中都有的元素存放在新数组里
val newArr = arr intersect sub
//差集 val ints: Array[Int] = v2020 diff v2021
//arr中有而sub中没有的元素
val newArr = arr diff sub
//尾部追加 val ints: Array[Int] = v2020 :+ 200
//arr尾部追加一个元素elem
val newArr = arr :+elem
//头部追加 val ints: Array[Int] = 220 +: v2020
val newArr = elem +: arr
//头删除n个元素
//n为负值：不删除元素；n大于数组size，全删；不报错
//arr drop(n:Int) 没有那个"."也不影响结果
val newArr = arr.drop(n:Int)
//尾删除n个元素
val newArr = arr.dropRight(n:Int)
//从集合的第一个元素开始，满足条件的drop掉，至第一个不满足条件的停止，后面再有满足条件的也不会drop掉了
val newArr = arr.dropWhile(f:Int=>Boolean)
//将源数组中从from(inclusive)开始的replaceLen个元素替换为sub
//若sub为空，则相当于删除源数组中从from(inclusive)开始的replaceLen个元素
//from和replaceLen的值都可以为负值或者大于数组的size
//from为负，sub在arr前面；from大于arr.size，sub在arr后面
//println(v2020.patch(0, Array(12), 11).mkString(",")) => Array(12,184)
//从数组下标0开始的11个元素，替换成Array(12)
val newArr = arr.patch(from:Int,sub:Genseq,replaceLen:Int)
//逐个迭代处理(5)
//println(v2021.map(_*2).mkString(","))
//println(v2021.mkString(","))
//384,376,338,310,366,240,260,244,320,354,288,334
//192,188,169,155,183,120,130,122,160,177,144,167 对原数组没影响
val tarr:Array[B] = arr.map(f:T=>B)
//println(v2021.transform(_*2).mkString(","))
//println(v2021.mkString(","))
//384,376,338,310,366,240,260,244,320,354,288,334
//384,376,338,310,366,240,260,244,320,354,288,334 对原数组有影响
var tarr:Array[B] = arr.transform (f:T=>B)
//先倒序，再map，不影响原数组
val tarr:Array[B]= arr.reverseMap (f:T=>B)
//降维
//val arr = Array(Array(123,234,345),Array(456,567,678))
//val tarr: Array[Int] = arr.flatten
val tarr:Array[T] = darr.flatten
//先map，再flatten，最后结果还是Array
//println(arr.flatMap(x => x.reverse).mkString(",")) => 345,234,123,678,567,456
var tarr:Array[B]= darr.flatMap (f:T=>B)
分组
//val par: ParArray[Int] = v2020.par
val parr:ParArray[T]= arr.par
//满足条件的一个数组，不满足条件的一个数组
var arr:(Array[T],Array[T]) = arr.partition(f:T=>Boolean)
//size : item size per group => sliding (n, n)<=>grouped(n)
//val iterator: Iterator[Array[Int]] = v2020.grouped(4)
//size个元素为一组，最后不足数量的为一组
var iter:Iterator[Array[T]] = arr.grouped(size:Int)
//val iterator: Iterator[Array[Int]] = v2020.sliding(4, 4)
var iter:Iterator[Array[T]] = arr.sliding(size:Int[,step:Int default 1])
//val intToInts: Map[Int, Array[Int]] = v2020.groupBy(_ % 3)
var iter:[(K,Array[T])] = arr.groupBy(key:K)
//数组中的元素组合排列的所有情况(与顺序有关)
val perm:Iterator[Array[Int]] = in.permutations
//n个元素组合的所有情况(与次序无关)
val iter:Iterator[Array[Int]] = in.combinations(n)
聚合
//v2020.reduce((x,y)=>{print(x+y+",");x+y})
//349,521,666,844,966,1101,1219,1375,1550,1678,1862,累加
val value:B = arr.reduce(f:(T,T)=>T)
val value:B = arr.reduceLeft(f:(B,T)=>B)
//val maybeInt: Option[Int] = v2020.reduceLeftOption((x, y) => {
// print(x + y + ",")
// x + y
//})
val value:B = arr.reduceLeftOption(f:(B,T)=>B)
//val i: Int = v2020.reduceRight((x, y) => {print(x + y + ",");x + y})
//312,487,643,761,896,1018,1196,1341,1513,1676,1862,
val value:B = arr.reduceRight(f:(T,B)=>B)
val value:B = arr.reduceRightOption(f:(T,B)=>B)
//v2020.fold(0)((x,y)=>{print(x+y+",");x+y})
//186,349,521,666,844,966,1101,1219,1375,1550,1678,1862,
val value:B = arr.fold[Left](initVal:B)(f:(B,T)=>B)=>/:
//v2020.foldRight(0)((x,y)=>{print(x+y+",");x+y})
//184,312,487,643,761,896,1018,1196,1341,1513,1676,1862,
//v2020.foldRight(0)((x,y)=>{print(x-y+",");x-y})
//184,-56,231,-75,193,-58,180,-2,147,25,138,48,
val value:B = arr.foldRight(initVal:B)(f:(T,B)=>B)=>:\
//fold返回最终结果，scan会将过程数据封装成数组返回
//v2020.scan(0)(_ + _) => 0,186,349,521,666,844,966,1101,1219,1375,1550,1678,1862
val value:Array[B] = arr.scan(initVal:T)(f:(T,T)=>T)
val value:Array[B] = arr.scanLeft(initVal:B)(f:(B,T)=>B)
//v2020.scanRight(0)(_ + _) => 1862,1676,1513,1341,1196,1018,896,761,643,487,312,184,0
//val ints: Array[Int] = v2020.scanRight(0)(_ - _)
//48,138,25,147,-2,180,-58,193,-75,231,-56,184,0
//初始值为0,184-0,128-184=-56,175-(-56)=231,156-231=-75,...
val value:Array[B] = arr.scanRight(initVal:B)(f:(T,B)=>B)
//v2020.par.aggregate(0)(_ + _, _ + _) => 1862
val value:B = arr.par.aggregate(initv:B)(map:(B,T)=>B,reduce:(B,B)=>B)=>速度快(并行)
//所有元素的和
//println("123456".sum.toInt) => 309
val value:T = arr.sum
//满足条件元素数量
val value:Int = arr.count(f:T=>Boolean)
//最小值
val value:T = arr.min
//最大值
val value:T = arr.max
//根据某一项取最小值
val value:T = arr.minBy(_.?) =>T:Tuple | class
//根据某一项取最大值
//Array(("jack", 18, "male"), ("rose", 19, "female")).maxBy(_._2)
val value:T = arr.maxBy(_.?) =>T:Tuple | class
验证
//数组是否为空
val bool:Boolean = arr.isEmpty
val bool:Boolean = arr.nonEmpty
//集合中是否存在符合参数函数条件（f）的元素
val bool:Boolean = arr.exists(f:Int=>Boolean)
//集合中是否包含参数元素（elem）的值
val bool:Boolean = arr.contains(elem:Int)
//集合中是否包含完整的参数序列（seq）
val bool:Boolean = arr.containSlice(sub:Genseq)
//集合中是否所有元素都符合参数条件
val bool:Boolean = arr.forall(p:Int=>Boolean)
//集合中是否所有参数按照索引顺序和参数序列符合参数函数特征
//v2020.corresponds(v2021)(_ + _ >200) => true
val bool:Boolean = arr.corresponds(sub:Genseq)(p:Int=>Boolean)
//集合和子集合是否具有相同的元素
val bool:Boolean = arr.sameElements(that:GenIterable[B])
//集合是否以参数子序列开头,可选参数offest：比较时arr的起始位置
val bool:Boolean = arr.startsWith(sub:Genseq[,offset:Int])
//集合是否以参数子序列结尾
val bool:Boolean = arr.endsWith(sub:Genseq)
大小
//数组长度|元素的数量
val len:Int = arr.length | size
//集合中从左侧开始连续满足参数函数条件的元素数量
//v2020.prefindexLength(x=>x.isInstanceOf[Int]) => 12
val len:Int = arr.prefiexLength(f:Int=>Boolean)
//从参数from位置开始(包含)连续满足参数函数条件的元素数量
val len:Int = arr.segmentLength(f:Int=>Boolean,from:Int)
//返回数组长度和参数长度的差值
//v2020.lengthCompare(15) => -3
val dif:Int = arr.lengthCompare(len:Int)
转变
//v2020.copyToArray(new Array[Int](12)),无返回值
copyToArray(arr:Array[T])
copyToBuffer(mutable.Buffer[T])
//"abcdefg".toArray.length => 7
val arr:Array[T] = arr.toArray
val arr:mutable.Buffer[T] = arr.toBuffer
//获取集合副本
//val array: Array[Int] = v2020.array
val arr:Array[T] = arr.array
//val clone1: Array[Int] = v2020.clone
val arr:Array[T] = arr.clone
//val repr: Array[Int] = v2020.repr
val arr:Array[T] = arr.repr
// val deep: IndexedSeq[Any] = v2020.deep
val arr:Indexedseq[T] = arr.deep
//val seq: mutable.IndexedSeq[Int] = v2020.seq
val arr:mutable.Indexedseq[T] = arr.seq
//键值映射Tuple2
//val arr = Array((123,234),(456,567))
//println(arr.toMap) => Map(123 -> 234, 456 -> 567)
//arr.toMap.foreach(println) => (123,234) (456,567)
val arr:Map[K,V] = arr.toMap
//去重<=> distince
//println(Array(12, 23, 22, 33, 22, 33).toSet) => Set(12, 23, 22, 33)
val set:Set[T] = arr.toSet
//只可迭代一次
val iter:Iterator[T] = arr.toIterator
//不定数量元素遍历(懒加载)
val stream:Stream[T] = arr.toStream
//如果arr.size<len,则将多余的长度填充为参数2:elem
//println(v2020.padTo(15,0).mkString(","))
val arr:Array[T] = arr.padTo(len:Int,elem:T)
//将集合从左侧第一个满足条件的元素开始至第一个不满足条件的元素结束作为一个数组
//剩余的元素作为另一个数组，将两者包装成元祖返回
//val tuple:(Array[Int], Array[Int]) = v2020.span(_ > 130)
val tp2:(Array[T],Array[T]) = arr.span(f:T=>Boolean)
//将集合以参数作为临界点(参数下标放于后者)分割成两个数组，并包装成元组返回
//val tuple: (Array[Int], Array[Int]) = v2020.splitAt(6)
val tp2:(Array[T],Array[T]) = arr.splitAt(index:Int)
//二维矩阵转置
//val arr = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))
//arr.transpose.foreach(x=>println(x.mkString(",")))
/* 如果数组中的9去掉的话，转置后原来9的位置会空出来
1,4,7
2,5,8
3,6,9
*/
val arr2d2:Array[Array[T]] = arr2d1.transpose
//将两个集合相同下标位置的两个元素组合成Tuple2,并将其包装成数组返回
//注意:如果两个集合长度不一致，则多余的长度将被忽略
//val tuples: Array[(Int, Int)] = v2020.zip(v2021)
//val unzip: (Array[Int], Array[Int]) = tuples.unzip
val arr:Array((T,B))= arr1[T].zip(arr2[B])
//将两个集合相同下标位置的两个元素组合成ruple2,并将其包装成数组返回
//如果arr1.size>arr2.size:则元组_2值由thatElem作为默认值
//如果arr1.size<arr2.size:则元组_1值由thisElem作为默认值
//val tuples: Array[(Int, Int)] = v2020.zipAll(v2021, 0, 0)
val arr:Array((T,B)) = arr1[T].zipAll(arr2[B],thisElem:T,thatElem:B)
//将由Tuple2构成的数组中_1和_2单独抽离并分别包装成2个数组，并包装成由两个数组构成的元组返回
//val unzip: (Array[Int], Array[Int]) = Array((186, 192),(145, 155),(178, 183)).unzip
var tp2:Tuple[Array[T],Array[T]] = arr[Array[Tuple2]].unzip
//将由ruple3构成的数组中_1、_2和_3单独抽离并分别包装成3个数组，并包装成由三个数组构成的元组返回
var tp3:Tuple3[Array[T],Array[T],Array[T]] = arr[Array[Tuple3]].unzip3
//将集合每个元素及其对应的下标包装成Tuple2，并将所有Tuple包装成数组返回
//val index: Array[(Int, Int)] = v2020.zipWithIndex
var tp2:Array((T,Int)) = arr.zipWithIndex
顺序(排序)
//倒序副本
val arr:Array[T] = arr.reverse
//倒序迭代器
val arr:Iterator[T] = arr.reverseIterator
//升序
val arr:Array[T] = arr.sorted
//x=>x升序x=>-x降序
val arr:Array[T] = arr.sortBy(f:T=>T)
//_<_升序 _>_降序
val arr:Array[T] = arr.sortWith(f:(T1,T2)=>Boolean)
拼接字符串
// val builder: StringBuilder = "world".addString(new mutable.StringBuilder("hello,"))
// println(builder.toString())
// hello,world
// val builder: StringBuilder = v2020.addString(new mutable.StringBuilder(),",")
// 186,163,172,145,178,122,135,118,156,175,128,184
val builder:StringBuilder = arr.addString(builder:StringBuilder[,sep:String])
//val builder: StringBuilder = v2020.addString(new mutable.StringBuilder(),"[",",","]")
//[186,163,172,145,178,122,135,118,156,175,128,184]
val builder:StringBuilder = arr.addString(builder:StringBuilder,start:String,sep:String,end:String)
//数组转换成字符串，以sep作为分隔符
var str:String = arr.mkString(sep:String)
//println(v2020.mkString("[", ",", "]"))
//数组转换成字符串，以sep作为分隔符，首位添上start和end
var str:String = arr.mkString(start:String, sep:String, end:String)
根据值取下标
//val in = Array(1, 2, 3, 4, 5, 5, 5, 4, 3, 2, 1)
//在数组arr中查找v第一次出现的下标，可指定查找的起始位置，不存在返回-1
val indexx:Int = arr.indexOf(v:T[,start:Int])
//在数组arr中查找切片sarr第一次出现的下标，可指定查找的起始位置，不存在返回-1
val index:Int = arr.indexOfSlice(sarr: GenSeq[,start:Int])
//在数组arr中查找满足条件的元素第一次出现的下标，可指定查找的起始位置
val index : Int = arr.indexWhere(f:T=>Boolean[,start:Int])
//in.lastIndexWhere(_ == 5,4) => 4
//查找元素v最后出现的位置，截止至下标end(含)
//in.lastIndexWhere(_ == 2) => 9
val index:Int = arr.lastIndexOf(v:T [,end:Int])
val index:Int = arr.lastIndexOfSlice(arr:Genseq [,end:Int])
val index:Int = arr.lastIndexWhere(f:T=>Boolean [,end:Int])
//val ran:Range = in.indices
//println(ran) => Range 0 until 11
val indexs:Range = arr.indices
793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
