Scala 中Array的算子

清欢渡12138

于 2021-07-29 20:56:03 发布

阅读量254

点赞数

文章标签： scala 大数据

本文链接：https://blog.csdn.net/weixin_49180684/article/details/119118868

版权

提取元素

val v:T = arr.head							提取第一个元素
val v:Option[T] = arr.headOption			提取第一个元素，返回值是一个Option类型，与上面相比，这个即使是空元素也不会报错，返回一个None
val v:T = arr.last							提取最后一个元素
val v:Option[T] = arr.lastOptin				提取最后一个元素，返回值类型是Option类型，空元素也不会报错

val v:T = arr(index:Int)						根据下标提取元素
val V:T = arr.apply(index:Int)					根据下标提取元素
val v:T = arr.applyOrElse(index:Int,f:(x:T)=>B)	根据下标提取元素，若参数1的下标越界，则将参数1传入参数2表达式，返回参数2表达式的结果

val arr:Array[T] = arr.take(size:Int)			从左边取size个元素
val arr:Array[T] = arr.takeRight(size:Int) 		从右边取size个元素
val arr:Array[T] = arr.takeWhile(f:T=>Boolean)	从下标0开始，从第一个满足条件的元素开始，到第一个不满足条件的元素结束，取中间的元素(如果第一个就不满足，那就一个都不取)

val arr:Array[T] = arr.filter(f:T=>Boolean)				提取集合中满足条件的元素
val arr:Array[T] = arr.filter(f:T=>Boolean)				提取集合中不满足条件的元素

val arr:Array[T] = arr.collect(PartialFunction[T,B]:T=>B) 		提取集合中所有满足参数偏函数条件的元素
val arr:Array[T] = arr.collectFirst(PartialFunction[T,B]=>B)  	提取集合中第一个满足参数偏函数条件的元素

val arr:Option[T] = arr.find(f:T=>Boolean)				提取集合中第一个满足条件的元素，没有就什么都不返回
val arr:Array[T] = arr.slice(begin:Int,end:Inf)			提取从begin到end之间的所有元素

val arr:Array[T] = arr.init 			提取出最后一个元素外的所有元素
val arr:Iterator[Array[T]] = arr.inits  提取除最后一个外的所有元素，并上一步的结果是下一步初值，封装成迭代器返回
val arr:Array[T] = arr.tail 			提取除第一个元素外的所有元素
val arr:Iterator[Array[T]] = arr.tails 	提取除第一个外的所有元素，并上一步的结果是下一步初值，封装成迭代器返回

val f:Int=>Option[Int] = arr.lift			返回一个可以根据下下包取值的函数

val f:PartialFunction[T,B] = arr.orElse(f:PartialFunction) 返回根据参数偏函数规则日趋数组元素的偏函数，若是下标越界，走偏函数是，下标不越界，提取对应元素

案例

//创建两个数组
val arr1 = Array(1,2,3,4,5,6)
val arr2 = new Array[Int](0)		//创建一个Int类型，长度为0的数组

head:
	println(arr1.head)
	输出结果：1
headOption：
	println(arr1.headOption)
	输出结果：Some(1)
	println(arr2.headOptin)
	输出结果：None
last:
	println(arr1.last)
	输出结果：4
lastOption:
	println(arr1.lastOption)
	输出结果：Some(4)
	println(arr2.lastOption)
	输出结果：None
直接输入下标
	println(arr1(1))
	输出结果：2
apply:
	println(arr1.apply(2))
	输出结果：3
applyOrElse:
	println(arr.applyOrElse(2,(ix:Int)=>ix*5)
	输出结果：3			//下标没越界，不走面函数
	println(arr.applyOrElse(10,(ix:Int)=>ix*5)
	输出结果：50			//下标越界，走后面函数，后面函数的返回值就是结果
take:
	arr1.take(3).foreach(print)
	输出结果：1 2 3
takeRight:
	arr1.takeRight(3).foreach(print)
	输出结果：4,5,6
takeWhile:
	arr1.takeWhile(_%2==1).foreach(print)
	输出结果：1				//第一个满足，到第二个就不满足了，所以只有一个元素输出
	arr1.takeWhile(_%2==0).foreach(print)
	输出结果：			//输出结果为空，因为第一个就吧满足，所以什么都么有
filter:
	arr1.filter(_%2==0).foreach(print)
	输出结果：2 4 6
filterNot:
	arr1.filter(_%2==0).foreach(print)
	输出结果：1 3 5
collect；
	arr1.collect{case x if(x%2==0) => x}.foreach(print)
	输出结果：2 4 6
collectFirst:
	println(arr1.collectFirst{case x if(x%2==0) => x})
	输出结果：Some(2)
	arr1.collectFirst{case x if(x%2==0) => x}.foreach(print)
	输出结果：2
	println(arr1.collectFirst{case x if(x%2==3) => x})
	输出结果：None
	arr1.collectFirst{case x if(x%2==0) => x}.foreach(print)
	输出结果：   		//输出结果为空。若果遍历输出，就什么都没有，如果直接输出就是None
slice:
	arr1.slice(1,3).foreach(print)
	输出结果：2 3 4
init:
	arr.init.foreach(print)
	输出结果：1 2 3 4 5
inits:
	arr1.inits.foreach(x=>{
		println()
		x.foreach(print)
	})
	输出结果：12345
		  	1234
		  	123
		  	12
		  	1

			//最后一行也有值，是空值，一共6行
tail:
	arr1.tail.foreach(print)
	输出结果：2 3 4 5 6
tails:
	arr1.tails.foreach(x=>{
		x.foreach(print)
		println()
	})
	输出结果：23456
			3456
			456
			56
			6
	
			//最后也有输出，只不过是空值
lift:
	var f = arr1.lift
	println(f(2))
	输出结果：Some(3)
orElse:
	val f = arr1.orElse{case x => x*10}
	println(f(2))
	println(f(8))
	输出结果：3
			80

修改操作

Unit arr.update(index:Int,newValue:T)		将指定index下标的值修改为newValue
val arr:Array[T] = arr.updated(index:Int,newValue:T)  将指定index下标的值修改为newValue，并将这个数组返回

val arr:Array[T] = arr1 ++ arr2 		并集
val arr:Array[T] = arr1 union arr2		并集
val arr:Array[T] = arr1 intersect arr2	交集
val arr:Array[T] = arr1.diff(arr2)		差集	arr1中不在arr2中的元素

val arr:Array[T] = arr :+ elem			尾部追加元素，冒号对着集合
val arr:Array[T] = elem +: arr			头部追加元素，冒号对着集合

val arr:Array[T] = arr.drop(n:Int)		从头开始删除n个元素 
val arr:Array[T] = arr.dropRight(n:Int)	从尾开始删除n个元素
val arr:Array[T] = arr.dropWhile(f:Int=>Boolean)	从头开始删除符合条件的元素，直到第一个不满足条件的元素结束，如果第一个就不满足条件，一个都不删除，返回删除元素之后集合的副本

val arr:Array[T] = arr.patch(from:Int,sub:Genseq,reolaceLen:Int)	将源数组从下标from位置开始，将replaceLen个元素替换为sub
	如果sub为空，就是删除从from开始的replaceLen个元素
	如果replaceLen是0，就是从from位置开始，往数组里面添加元素

案例

//创建两个数组
val arr1 = Array(1,2,3,4)
val arr2 = Array(2,3,4,5)
val arr3 = new Array[Int](0)

update:
	arr1.update(1,6)
	arr1.foreach(print)
	输出结果：1 6 3 4
updated:
	arr.updated(0,6).foreach(print)
	输出结果: 6 2 3 4
++  union
	arr1 ++ arr2.foreach(print)
	arr1 union arr2.foreach(print)
	输出结果：1 2 3 4 2 3 4 5
intersect
	arr1 intersect arr2.foreach(print)
	输出结果：2 3 4 
diff 
	arr1.diff(arr2).foreach(print)
	输出结果：1		//arr1中不在arr2中的元素
:+
	val arr = arr1 :+ 6
	arr.foreach(print)
	输出结果：1 2 3 4 6
+:
	val arr = 6 +: arr1
	arr.foreach(print)
	输出结果：6 2 3 4 5
drop
	arr1.drop(2).foreach(print)
	输出结果：3 4
dropRight
	arr1.dropRight(2).foreach(print)
	输出结果：1 2 
dropWhile
	arr1.dropWhile(_%2==0).foreach(print)
	输出结果：1 2 3 4 		//因为第一个就不满足条件，所有一个都没有删除
	arr1.dropWhile(_%2==1).foreach(print)
	输出结果：2 3 4 			//第一个满足条件为了，但是到第二个就不满足了，所以只删除了一个元素
patch
	arr1.patch(1,Array(9,8,7),2).foreach(print)
	输出结果：1 9 8 7 4				//替换
	arr1.patch(1,arr3,2).foreach(print)
	输出结果：1 4						//相当于删除元素
	arr1.patch(1,Array(9,8,7),0).foreach(print)
	输出结果：1 9 8 7 2 3 4			//相当于从下标1开始新增元素

逐个迭代处理

val tarr:Array[B] = arr.map(f:T=>B)			将arr数组中的每个元素都拿出来经过函数f的处理
val tarr:Array[B] = arr.transfrom(f:T=>B)	将arr数组中的每个元素都拿出来经过函数f的处理
val tarr:Array[B] = arr.reverseMap(f:T=>B)	将arr数组倒序之后，在将其中的每个元素都拿出来经过函数f的处理
val tarr:Array[B] = arr.flatten				降维，将二维数组，变成一维
val tarr:Array[B] = arr.flatMap(f:T=>B)		将二维数组中的一维数组中的每个元素拿出来进行map操作，经过函数f处理，在将二维数组进行flatten降维处理

案例

//创建两个数组
val arr1 = Array(1,2,3)
val arr2 = Array(Array(1,2),Array(3,4))

map:
	arr1.map(_*2).foreach(print)
	输出结果：2 4 6
transform
	arr1.transform(_*2).foreach(print)
	输出结果：2 4 6
reverseMap:
	arr1.reverseMap(_*2).foreach(print)
	输出结果：6 4 2
flatten
	arr2.flatten.foreach(print)
	输出结果：1 2 3 4		//将二维数组，变成了一维数组，所有元素都在一维数组里
flatMap
	arr2.flatMap(x=>{	//x代表二维数组中的每一个元素，二维数组中的每个元素是一维数组
      x.map(_*2)		//每个一维数组，在进行map操作，
    }).foreach(println)
	输出结果： 2 4 6 8

分组

val par:ParArray[T] =  arr.par		对数组进行分组
val arr:(Array[T],Array([T]) = arr.partition(f:T=>B)	根据后面的参数函数将数组分成两个数组，然后组成一个元组，符合条件的放在前那个数组，不符合放在后面的数组，
val iter:Iterator[Array[T]] = arr.grouped(size:Int)		数组根据size个数进行分组
val iter:Iterator[Array[T]] = arr.silding(size:Int[,step:Int])	将数组元素根据size个数进行分组，步幅是step个
val arr:(k,Array[T]) = arr.groupBy(Key:K)		根据一个元素对数组进行分组，将key元素相同的数组放在一个数组里

案例

val arr1 = Array(1,2,3,4)
val arr2 = Array(("a",1),("a",2),("b",2))

par
	arr1.par		//这就将数组分组了，也不知道咋分的

partition
	val tp = arr1.partition(_%2==0)
	tp._1.foreach(print)
	tp._2.foreach(print)
	输出结果：2 4
			1 3
silding
	arr1.sliding(2).foreach(x=>{
      x.foreach(y=>print(s"$y\t"))
      println()
    })
    输出结果：1 2 
    		2 3
    		3 4		//这样输出是以两个元素为一组，默认的步幅是1
    arr1.sliding(2，2).foreach(x=>{
      x.foreach(y=>print(s"$y\t"))
      println()
    })
	输出结果：1 2
			3 4		//两个元素为一组，步幅是2
groupBy
	  arr1.groupBy(_%2==0).foreach(x=>{
      print(x._1)
      x._2.foreach(y=>print(s"\t$y\t"))
      println()
    })
    输出结果：false	1		3	
			true	2		
			//前面的是分组的根据，条件表示返回的布尔值
		//也可以用键值对的键来分组

聚合

val value:B = arr.reduce(f:T=>B)		根据参数函数对数组内容进行聚合
val value:B = arr.reduceLeft(f:T=>B)	根据参数函数对数组内容进行聚合,和reduce一样，从左往右
val value:B = arr.reduceLeftOption(f:T=>B)	根据参数函数对数组内容进行聚合，和上面一样，对空数据容错
val value:B = arr.reduceRight(f:T=>B)	根据参数函数对数组内容进行聚合,从右往左开始聚合
val value:B = arr.reduceRightOption(f:T=>B)	根据参数函数对数组内容进行聚合,从右往左开始聚合,对空数据容错

val value:B = arr.fold(initval:T)(f:T=>B)	从给的参数1初值根据参数2函数进行规约，从左往右	和【/:】 一样
val value:B = arr.foldLeft(initval:T)(f:T=>B)	从给的参数1初值根据参数2函数进行规约，从左往右 
val value:B = arr.foldRight(initval:T)(f:T=>B)	从给的参数1初值根据参数2函数进行规约，从右往左

val value:Array[B] = arr.scan(initval)(f:(T,T)=>B)	返回每一个步骤计算结果的集合，返回了每一个计算结果,从左往右
val value:Array[B] = arr.scanLeft(initval)(f:(T,T)=>B)	返回每一个步骤计算结果的集合，返回了每一个计算结果，从左往右
val value:Array[B] = arr.scanRight(initval)(f:(T,T)=>B)	返回每一个步骤计算结果的集合，返回了每一个计算结果,从右往左

val value:B = arr.par.aggtrgate(init:B)(map:(T,T)=>B,reduce:(B,B)=>B)	并行计算，？？

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		找到数组中元组指定位置的最小值，其他功能不明
val value:T = arr.maxBy (_.?) =>T:Tuple | class		返回第一个满足条件的值,或者指定数组中包含元组，某个位置的最大值

案例

val arr1 = Array(1,2,3,4)
val arr2 = Array(("henry", "male", 11), ("ariel", "female", 22), ("pola", "male", 33), ("jack", "male", 44), ("roles", "female", 55))

reduce 、reduceLeft、reduceLeftOption
	println(arr1.reduce(_+_))
	println(arr1.reduceLeft(_+_))
	pritln(arr1.reduceLeftOption(_+_))
	输出结果：10
			10
			10		//如果有空数组，不会报错，会返回Option类型值None
reduceRight	、 reduceRightOption
	println(arr1.reduceRight(_+_))
	pritnln(arr1.reduceRightOption(_+_))
	输出结果：10		//4+3+2+1
			10		//4+3+2+1		有控制不会报错，会返回Option类型值
fold 、 foldLeft
	println(arr1.fold(5)(_+_))
	println(arr1.foldLeft(5)(_+_))
	输出结果：15		//5+1+2+3+4
			15		
foldRight
	println(arr1.foldRight(5)(_+_))
	输出结果：15		//5+4+3+2+1
scan  scanLeft
	arr1.scan(0)(_+_).foreach(println)
	arr1.scanLeft(0)(_+_).foreach(println)		//两个输出结果一样
	输出结果：1		//0+1=1
			3		//1+2=3
			6		//3+3=6
			10		//6+4=10
sum
	println(arr1.sum)
	输出结果：10
count
	println(arr1.count())
	输出结果：4
max:
	println(arr1.max)
	输出结果：4
min 
	printn(arr1.min)
	输出结果：1
maxBy
	返回第一个满足条件的值,或者指定数组中包含元组，某个位置的最大值        
     println(arr1.maxBy(_>3)
     输出结果是：4
     println(arr3.maxBy(_._3))		//指定某个数值的最大或者最小
     输出结果是： (roles,female,55)
minBy
	指定数组中包含元组，某个位置的最小值 
   	println(arr3.minBy(_._3))     //指定某个数值的最大或者最小
     输出结果是：(henry,male,11)

验证

val bool:Boolean = arr.isEmpty							//验证是否为空
val bool:Boolean = arr.nonEmpty							//是否不为空
val bool:Boolean = arr.exists(p:Int=>Boolean)			//集合中是否存在符合参数函数条件的元素
val bool:Boolean = arr.contains(elem:Int)				//集合中是否包含参数元素的值
val bool:Boolean = arr.containsslice(sub:Genseq)		//集合中是否包含完整的参数序列
val bool:Boolean = arr.forall(p:Int=>Boolean)			//集合中是否所有元素都符合参数条件
val bool:Boolean = arr.corresponds(sub:Genseg)(p:Int=>Boolean)	//集合中是否所有参数按照索引顺序和参数序列符合参数函数特征
val bool:Boolean = arr.sameElements(sub:Genseq)			//集合和子集合是否具有相同的元素
val bool:Boolean = arr.startswith(sub:Genseq)			//集合是否以参数子序列开头
val bool:Boolean = arr.endswith(sub:Genseq)				//集合是否以参数子序列结尾

案例

val arr1 = Array(1,2,3,4)
val arr2 = new Array[Int](0)

isEmpty
	println(arr1.isEmpry)
	输出结果：false
nonEmpty
	println(arr1.nonEmpty)
	输出结果：true
exists
	println(arr1.exists(_%2==0))
	输出结果：true
contains
	ptintln(arr1.contains(1))
	输出结果：true
containsSlice
	println(arr.containsSlice(Array(2,4)))
	输出结果：false
forall
	pritnln(arr1.forall(_%2==0))
	输出结果：false

大小

val len:Int = arr.length|size		返回数组长度
val len:Int = arr.prefixLength(f:Int=>Boolean)	//集合中从左侧开始连续满足参数函数条件的元素数量
val len:Int = arr.segmentLength(f:Int=>Boolean,pos:Int)		//从参数2位置开始(包含)连续满足参数函数条件的元素数量
val dif:Int = arr.lengthCompare(len:Int)	//返回数组长度和参数长度的差值

转换

copyToArray (arr:Array[T])			复制一个数组副本，不可变
copyToBuffer (mutable.Buffer[T])	复制一个数组副本，类型变成toBuffer类型
val arr:Array[T]= arr.toArray		将类型转换成Array类型
val arr:mutable.Buffer[T]= arr.toBuffer		将类型转换成Buffer类型

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 arr:set[T] = arr.toset					//去重<=> 	distince
val arr:Iterator[T] = arr.toIterator		//一次迭代
val arr:stream[T] = arr.tostream			//不定数量元素遍历(懒加教)

val arr:Array[T] = arr.padTo(len:Int,elem:T)	//填空，以参数2作为默认值填空全部剩余元素，如果长度不满足参数1,就是，就用默认值去补上   参数1是长度，参数2是要填充的元素

//将集合从左侧第一个满足条件的元素开始至第一个不满足条件的元素结束作为一个数组
//剩余的元素作为另一个数组，将两者包装成元祖返回
val tp2:(Array[T],Array[T]) = arr.span(f:T=>Boolean)

//将集合以参数作为临界点(参数下标放于后者)分割成两个数组，并包装成元祖返回
val tp2:(Array[T],Array[T]) = arr.splitAt(index : Int)

//二维矩阵转置
val arr2d2:Array[Array[T]] = arr2d1.transpose;
   
//将两个集合没相同位置下标的两个元素组合成Tuple2,并将其包装成数组返回
//注意:如果两个集合长度不一致，则多余的长度将被忽略
val arr:Array((T,B))= arr1[T].zip(arr2[B])

//将两个集合没相同位置下标的两个元素组合成ruple2,并将其包装成数组返回
//如果arr1.size>arr2.size:则元祖_2值由thatElem作为默认值
//如果arr1.size<arr2.size:则元祖_1值由thisElem作为默认值
val arr:Array((T,B)) = arr1[T].zipAll(arr2[B],thisElem:T,thatElem:B)

//将由Tuple2构成的数组中_1和_2单独抽离并分别包装成2个数组，并包装成由两个数组构成的元祖返回
var tp2 : Tuple [Array[T],Array[T]] = arr[Array [ruple2] ].unzip

//将由ruple3构成的数组中_1、_2和_3单独抽离并分别包装成3个数组，并包装成由三个数组构成的元祖返回
var tp3:Tuple3[Array[T] ,Array[T],Array[T]] = arr[Array[Tuple3]].unzip3

//将集合每个元素及其对应的下标包装成Tuple2，并将所有Tuple包装成数组返回
var tp2:Array((T,Int)) = arr.zipwithIndex;

案例

val arr1 = Array(1,2,3,4)

padTo
	arr1.padTo(5,66)。foreach(print)
	输出结果：1,2,3,4,66		//只有超出数组长度才填充
span
	val tp = arr.span(_%2==1)
	println(tp._1.mkString(","))
    println(tp._2.mkString(","))
	输出结果：（1）	(2，3，4)		//第二个就不满足条件
	val tp = arr.span(_>10)
	println(tp._1.mkString(","))
    println(tp._2.mkString(","))
	输出结果：        (1,2,3,4,5)		//前面一个是空，后面是第二个元组
splitAt
	返回的是一个元组，元组里面是数组
    val tp: (Array[Int], Array[Int]) = arr.splitAt(3)
    println(tp._1.mkString(","))
    println(tp._2.mkString(","))
    输出结果：1，2,3		4

拼接字符串

var str:string = arr.addstring(builder:stringBuilder[,sep:string])			//前提需要一个stringBuilder类型的对象
var str:string = arr.addstring(builder:stringBuilder,start:string,sep:string,end:String)
var str:String = arr.mkstring(sep:string)		直接拼接
var str:string = arr.mkstring(start:string,sep:string,end:string)

案例

addString
	val builder = new StringBuilder
	有三个重载功能,一个啥也不加，一个加分隔符，一个加开始结束符号
    val str:StringBuilder = arr1.addString(builder)
    val str:StringBuilder = arr1.addString(builder,",")
    val str:StringBuilder = arr1.addString(builder,"{",",","}")

mkstring	
	val str:StringBuilder = arr1.mkString			//啥也不加
    val str:StringBuilder = arr1.mkString(",")    	//加一个分隔符
    val str:StringBuilder = arr1.mkString("{",",","}")	//加分隔符，开始结束符号

根据值取下标

val ix:Int = arr.indexof(v:T[,start:Int])		获取集合中包含元素的下标，从左到右首次出现的参数1的下标，或者从指定参数2的位置开始找到第一次出现元素的下标
val ix:Int = arr.indexofslice(arr:Genseq[,start:Int])	获取集合中从左向右第一个连续等于参数1子序列值首元素下标，或者从指定参数2的位置开始找到第一次出现第一个元素的下标
val ix:Int = arr.indexofwhere(f:T=>Boolean [ ,start:Int])	获取集合中从左向右第一个符合参数函数条件值的下标	，或者从指定参数2的位置开始找到第一次出现第一个元素的下标

val ix:Int = arr.lastIndexof(v:T[,start:Int])	获取集合中包含元素的下标，从右到左首次出现的参数1的下标，或者从指定参数2的位置开始找到第一次出现元素的下标
val ix:Int = arr.lastIndexofslice (arr:Genseq[,start:Int])	获取集合中从右向左第一个连续等于参数1子序列值首元素下标，或者从指定参数2的位置开始找到第一次出现第一个元素的下标
val ix:Int = arr.lastIndexofwhere(f:T=>Boolean[,start:Int])	获取集合中从右向左第一个符合参数函数条件值的下标	，或者从指定参数2的位置开始找到第一次出现第一个元素的下标

val ixs:Array [Int] = arr.indices		返回数组所有下标序列， 把数组的下标作为一个连续的序列作为结果返回

其他

函数组装
val f3 = fl andThen f2		=>f3(V)先执行f1再执行f2
val f4= fl compose f2		=>f3(V)先执行f2再执行f1


asInstanceof		//强制类型转换
isInstanceof		//类型判定

清欢渡12138

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Scala 中Array的算子

提取元素val v:T = arr.head 提取第一个元素val v:Option[T] = arr.headOption 提取第一个元素，返回值是一个Option类型，与上面相比，这个即使是空元素也不会报错，返回一个Noneval v:T = arr.last 提取最后一个元素val v:Option[T] = arr.lastOptin 提取最后一个元素，返回值类型是Option类型，空元素也不会报错val v:T = arr(index:Int) 根据下标
复制链接

扫一扫

Scala 中Array的算子

提取元素

修改操作

逐个迭代处理

分组

聚合

验证

大小

转换

拼接字符串

根据值取下标

其他

“相关推荐”对你有帮助么？