scala array算子

#算子（函数|方法）Array
       val array =Array(...)

       //提取21+1
       array.foreach(consumer:(T)=>Unit)   //遍历所有元素
       val t:T = array(index:Int)               //根据下标提取元素   存在下标越界异常 println(array(0))
       val t:T= array.apply(index:Int)           //根据下标提取元素，存在下标越界异常   println(array.apply(1))
       val t:T= array.applyOrElse(index:Int,d:(a:Int)=>Any)       //根据下标提取元素，若下标越界，默认返回参数2函数的返回值（也可以根据Map的key获取value）
       val t:T= array.head                       //提取头元素，空数据报NoSuchElementException异常
       val t:T= array.last                       //提取尾元素，空数据报NoSuchElementException异常
       val opt:Option[T]= array.headOption   //提取头元素，配合isEmpty判定，安全提取
       val opt:Option[T]= array.lastOption   //提取尾元素，配合isEmpty判定，安全提取

       val sub:Array[T] = array.take(count:Int)//从从左侧提取count个元素
       val sub:Array[T] = array.takeRight(count:Int)//从从右侧提取count个元素
       val sub:Array[T] = array.takeWhile(predicate:(T)=>Boolean)//从从左侧提取满足predicate条件的元素
       //从下标0开始提取，若第一个元素不满足，返回空数组；否则从左边第一个满足元素开始，到第一个不满足元素结束

       val sub:Array[T] =array.filter(predicate:(T)=>Boolean).foreach(println)   //提取所有满足参数函数条件的元素
       val sub:Array[T] =array.filterNot(predicate:(T)=>Boolean).foreach(println)   //提取所有不满足参数函数条件的元素
       val sub:Array[T] =array.collect(pf:PartialFunction[T,R])//提取所有满足参数函数条件（偏函数）的元素（过滤处理，比filter性能高）
       val opt:Option[T] =array.collectFirst(pf:PartialFunction[T,R])//提取集合中第一个满足参数函数条件的Option【元素】

val opt:Option[T]= =array.find(f:(T)=>Boolean)       //提取左边第一个满足参数函数条件的元素（处理，性能没有collectFirst高）
       val sub:Array[T] =array.slice(from:Int,until:Int) //提取下标从from到until之间的元素（左闭右开）
       val sub:Array[T]=array.init               //提取排除最后一个元素之外的所有元素
       val it:Iterator<Array[T]>=array.inits   //递归依次提取排除最后一个元素之外的所有元素
       val sub:Array[T]=array.tail               //提取排除第一个元素之外的所有元素
       val it:Iterator<Array[T]>=array.tails       //递归依次提取排除第一个元素之外的所有元素

       val f:(ix:Int)=>Option[T] =array.lift           //获取以下标为参数提取Option数组元素的函数   （函数既可以作为参数，也可以作为返回值）

       #修改12
       array.update(ix:Int,t:T)               //修改原数组指定下标位置的元素值（无返回值，元数组改变）*
       valnewarr:Array[T]=array.updated(ix:Int,t:T)//修改数组指定下标位置的元素值，冰女返回修改后的数组（元数组不变）

       val uArr:Array[T] = array1 ++ array2   //并集（和union一样）
       val uArr:Array[T] = array1 union array2//并集（重复的部分存在两次）
       val uArr:Array[T] = array1 intersect array2//交集
       val uArr:Array[T] = array1 diff array2   //差集（前者相对于后者的差集）

       val uArr:array[T]= array :+ t       //尾部追加
       val uArr:array[T]= t +: array        //头部追加

       val uArr:array[T]= array.drop(count:Int)   //返回删除左侧count个元素的副本（返回新数组，元数组不变）
       val uArr:array[T]= array.dropRight(count:Int)//返回删除右侧count个元素的副本
       val uArr:array[T]= array.dropWhile(f:T=>Boolean )//返回删除从左侧开始符合参数函数条件元素的副本，若左一不满足不删除

       val uArr:array[T]= array.patch(from:Int,seq:GenSeq[T],count:Int) //将从from开始的count个元素替换为seq；如若seq为空，则删除（删除+插入）

       //逐个处理（迭代）(很重要)5
       val uArr:array[T]= array.map(f:T=>U)   //正向迭代处理
       val uArr:array[T]= array.transform(f:T=>U)//正向迭代处理
       val uArr:array[T]= array.reverseMap(f:T=>U)//反向迭代处理
       val uArr:array[T]= 2DArr.flatten           //（扁平化，面向多维数组）降一个维度
       val uArr:array[T]= 2DArr.flatMap(f:Array[T]=>U)//（flatMap=flatten.map）降一个维度并处理

       //分段|组（重要）5
       val parArr:ParArray[T] =array.par//并行数组（提供并行处理机制，开启线程处理，用来提速）
       val tp2:(Array[T],Array[T])=array.partition(f:T=>Boolean)//（分区，多元祖）按参数函数条件分为两个（或多个）数组并封装成二元组（多元祖）返回
       val tp2:(Array[T],Array[T])=array.span(f:T=>Boolean)//（封装成二元组返回），满足的元素组成的数组和不满足条件的元素组成的数组组成一个二元组
       //从下标0开始提取，若第一个元素不满足，返回（空集，全集）组成的二元组，否则第一组从左边第一个满足元素开始，到第一个不满足元素结束，剩余第二组
       val tp2:(Array[T],Array[T])=array.splitAt(ix:Int)//以参数下标为界，将集合一分为二，被封装成二元组返回
       val it:Iterator[Array[T]]= array.grouped(size:Int)   //（分组，为了并行处理）按指定每组元素数量分组(this.length/size).ceiling
       val it:Iterator[Array[T]]= array.sliding(size:Int,step:Int)//滑动分组（每组size个元素，每次步进step步，step默认为1）(Map滑动分组，键键合并，值和值合并)
       val map:Map(K,Array[T])= array.groupBy(key:K)   //按键分组（T:为多元祖|样例类）（会导致数据倾斜）

       //聚合18
       val rst:T =array.reduce(f:(T,T)=>T)   //对数组从左向右执行参数函数运算（不带初值）
       val rst:T =array.reduceOption(f:(T,T)=>T)   //等同于reduce,防UnsupportedOperationException，结果包装成Option
       val rst:T =array.reduceLeft(f:(T,T)=>T)//等同于reduce
       val rst:T =array.reduceLeftOption(f:(T,T)=>T)//等同于reduce，防UnsupportedOperationException，结果包装成Option
       val rst:T =array.reduceRight(f:(T,T)=>T)//对数组从右向左执行参数函数运算
       val rst:T =array.reduceRightOption(f:(T,T)=>T)//等同于reduceRight,防UnsupportedOperationException，结果包装成Option
       //↑（第一次拿前两个元素计算，第二次开始拿上一次的结果和当前元素计算）

       //⬇（第一次拿t和第一个元素计算，第二次开始拿上一次的结果和当前元素计算）
       val rst:T =array.fold(t:T)(f:(T,T)=>T)   //左折叠（最终结果）（带初值）
       val rst:T =array.foldRight(t:T)(f:(T,T)=>T)   //右折叠（最终结果）
       val rst:Array[T] =array.scan(t:T)(f:(T,T)=>T)//左折叠（将过程结果封装成数组返回）
       val rst:Array[T]=array.scanLeft(t:T)(f:(T,T)=>T)//左折叠（将过程结果封装成数组返回）
       val rst:Array[T]=array.scanRight(t:T)(f:(T,T)=>T)//右折叠（将过程结果分装成数组返回）（结果逆序）

       val rst:T =array.par.aggregate(s:()=>T)(map:(T,T)=>T,red:(T,T)=>T)//并行序列并行计算

val t:T = array.sum //累加和
       val t:T = array.count(f:(T)=>Boolean) //统计符合参数函数条件的元素数量
       val t:T = array.max //最大值
       val t:T = array.min //最小值
       val t:T = array.maxBy(f:(T)=>Boolean) //满足参数函数条件的第一个值
       val t:T = array.minBy(f:(T)=>Boolean)//不满足参数函数条件的第一个值

       //验证9+1
       val rst:Boolean= array.isEmpty                   //是否为空
       val rst:Boolean= array.nonEmpty                   //是否不为空
       //val rst:Boolean= array.exists(p:Int=>Boolean) //是否存在符合参数函数条件的元素（可以使用count达到类似效果）
       val rst:Boolean= array.contains(ele:T)           //是否包含参数元素
       val rst:Boolean= array.containsSlice(seq:GenSeq)//是否包含子序列（空序列，顺序相同的所有子序列元素）println(array.containsSlice(GenSeq(1,2,3)))
       val rst:Boolean= array.forall(f:(T)=>Boolean)   //是否所有元素都满足参数函数的条件
       val rst:Boolean= array.corresponds(sub:GenSeq[B])(f:(Int，B)=>Boolean)   //是否arrayhe和sub同索引元素都满足参数函数条件（array.size= sub.size）
       val rst:Boolean= array.sameElements(seq:GenSeq[T])//array和sub是否完全相同（数值，顺序一致）
       val rst:Boolean= array.startsWith(seq:GenSeq[T])//array是否以seq开头
       val rst:Boolean= array.endsWith(seq:GenSeq[T])//array是否以seq结尾

       //大小5
       val len:Int = array.size       //获取元素数量
       val len:Int = array.length       //同size
       val len:Int = array.prefixLength(f:(T)=>Boolean)//获取左侧（从下标0开始）连续满足参数函数条件的元素数量，否则返回0
               //等同于array.segmentLength(f:(T)=>Boolean,0)
       val len:Int = array.segmentLength(f:(T)=>Boolean,pos:Int)//获取从pos开始连续满足参数函数条件的元素数量，否则返回0
       val len:Int = array.lengthCompare(len:Int)   //获取（array.size-len）的差值

       //转变19+1（to...自动创建）
       //(事先要创建sub数组)
       array.copyToArray(sub:Array[T],start:Int,len:Int)   //将array从0开始复制len个元素到数组sub的start开始
       array.copyToArray(sub:Array[T],start:Int)   //array.copyToArray(sub,start,Math.min(sub.length-start,array.size))
       array.copyToArray(sub:Array[T])   //array.copyToArray(sub,0,Math.min(sub.length,array.size))
       array.copyToBuffer(sub:ArrayBuffer[T])       //将array中所有元素复制到sub中（ArrayBuffer可变集合）

       var arr:Array[T]= array.toArray       //获取当前数组的引用：等同于arr=array（还是原数组）
       var buffer:Buffer[T]= array.toBuffer   //获取arrayBuffer类型的拷贝（重新创建数组）**
       var set:Set[T]=array.toSet       //获取Set类型拷贝（自带去重，无序）*
       vararr:Array[T]= arr.distinct   //去重*
       var arr:Array[T] = array.clone   //浅克隆（引用）
       var arr:Array[T] = array.repr   //等同于clone
       var arr:Array[T] = array.deep   //深克隆（把元素都克隆,返回类型IndexedSeq[Any]）
       var arr:Map[K,V]= array.toMap   //获取Map的拷贝（一般array元素类型为二元组（二元组转化为map），其他类型会涉及到隐式参数）*
       val stream:Stream[T] =array.toStream //获取流对象，懒加载

       //var arr:Array[T] = array.padTo(len:Int,elem:T)/如果arr.size<len,则将多余的长度填充参数2（elem）

       val arr2d:Array[Array[T]]=arr2d.transpose   //二维数组转置（行转列，列转行）
       val newArr:Array[(T,B)]=array1.zip(array2:GenIteralbe)       //两个数组同下标组合成二元组,并将所有二元组封装成数组返回
       val newArr:Array[(T,B)]=array1.zipAll(array2:GenIteralbe,thisEle:T,thatEle:B)   //两个数组同下标组合成二元组,并将所有二元组封装成数组返回(数据补全)
       //（array1缺失，用thisEle补全;array2缺失用thatEle补全）
       val newArr:Array[(T,Int)]=array.zipWithIndex   //将元素和下标包装成二元组，并将所有二元组分装成数组返回（元素在前，下标在后）
       val tp2:( Array[T],Array[B])=tp2arr.uzip //（拆）按二元组组成的数组拆成的两个数组并封装成二元组返回
       val tp3:(Array[T],Array[B]，Array[C])=tp3arr.uzip3 //按三元组组成的数组拆成的三个数组并封装成三元组返回
       //(多元祖组成的数组可以通过map操作，得的想要的多元组)

       //顺序（排序）5
       //数组和迭代器进行遍历的区别：迭代器是一次性的，数组是可以多次的
       val arr:Array[T]= array.reverse//逆序array（翻转）
       //val arr:Array[T]= array.reverseMap//reverse+map
       val arr:Iterator[T]= arr.reverseIterator//逆序迭代器
       val ascArr:Array[T]= array.sorted   //排序
       //配合隐式参数可将默认升序排序方式改为降序排序（ implicit val DESC= Ordering[Int].reverse //隐式参数）
       //隐式参数(类型匹配，自动调用（所以要精准匹配，类型最小化，严格控制数量）)
       val sortedArr:Array[T]= array.sortBy(a:T=>T)   //排序（a=a升序，a=-a降序）
       val sortedArr:Array[T]= array.sortWith(f:(T,T)=>Boolean)//排序（a<b 升序，a>b降序）

       //字符串拼接2
       val str:String = array.mkString(sep:String)   //以参数指定的分隔符拼接
       val str:String= array.mkString(start:String,sep:String,end:String)//以参数指定的分隔符拼接

       //查找9
       val index:Int= array.indexWhere(p:T=>Boolean)   //左起查找第一个满足参数函数条件元素的下标，无返回-1；
       val index:Int= array.indexWhere(p:T=>Boolean,start:Int)   //左（下标start包含）起查找第一个满足参数函数条件元素的下标，无返回-1；
       val index:Int= array.indexOfSlice(seq:GenSeq)   //左起查找第一个完全匹配参数序列的首元素下标，无返回-1
       val index:Int= array.indexOfSlice(p:T=>Boolean,start:Int)   /左（下标start包含）起查找第一个完全匹配参数序列的首元素下标，无返回-1
       val index:Int= array.lastIndexWhere(p:T=>Boolean)   //右起查找第一个满足参数函数条件元素的下标，无返回-1；
       val index:Int= array.lastIndexWhere(p:T=>Boolean.start:Int)   //右（start包含）起查找第一个满足参数函数条件元素的下标，无返回-1；
       val index:Int= array.lastIndexOfSlice(seq:GenSeq)   //右起查找第一个完全匹配参数序列的首元素下标，无返回-1
       val index:Int= array.lastIndexOfSlice(p:T=>Boolean.start:Int)   //右（start包含）起查找第一个完全匹配参数序列的首元素下标，无返回-1
       val ixRng:Rang= array.indicies       //获取数组的下标【区间】

object ArrayFuncs {def main(args: Array[String]): Unit = {//        val array:Array[Int] = Array(1,2,3,4,5,6,7,8,9)//提取21********************************************************************************************/*          val test:Map[Int,String]=array.foreach(println)//    //遍历所有元素println(array(2))println(array.apply(1))println(array.applyOrElse(-3, (i:Int) => -1))println(array.applyOrElse(-1, (i:Int) =>s"Exception:  $i"))val head = array.headval head = array.lastprintln(head)*//* val opt = array.headOptionif (opt.isEmpty) {println("EMPTY")} else{println(opt.get)}println(array.head)*//*      array.take(3).foreach(println)array.takeRight(3).foreach(println)array.takeWhile((a:Int)=>a<3).foreach(println)array.filter((a:Int)=>a%2==0).foreach(println)*///模式匹配，要满足所有的情况，缺失会报错/* val f = (a:Int)=>a match{case x if(x%2==0)=>xcase _=> -1}val test = (arr:Array[Int],f:(Int)=>Int)=>{arr.foreach((a:Int)=>{println(f(a))})}test(array,f)*///模式匹配，要满足所有的情况，缺失会报错//偏函数只要考虑想要的情况/* val p:PartialFunction[Int,Int]=(a:Int)=> a match {case x if(x%2==0)=> x}//面向数组array.collect(p).foreach(println)*//*array.collect({case x if(x%2==0)=>x}).foreach(println)*//* array.collectFirst({case x if(x>3)=>x}).foreach(println)val maybeInt:Option[Int] = array.collectFirst({case x if (x > 6) => x})println(maybeInt.isEmpty)println(maybeInt.get)*//*val maybeInt:Option[Int] = array.find((a: Int) => a > 1)println(maybeInt.get)*//* val sub = array.slice(2, 4)sub.foreach(println)*//*var sub: Array[Int] = array.initwhile(!sub.isEmpty){println(sub.mkString(","))sub = sub.init}*///求累加和/*  var sub: Array[Int] = arraydo {println(sub.sum)sub = sub.init} while(!sub.isEmpty)*//*    var sub: Array[Int] = arraydo {println(sub.mkString(","))sub = sub.tail} while(!sub.isEmpty)*//*array.inits.foreach(a=>println(a.mkString(",")))array.tails.foreach(a=>println(a.mkString(",")))*//*val lift:Int =>Option[Int]= array.liftval maybeInt :Option[Int]= lift(5)println(maybeInt)*//*  var opt1:Option[String] = Some("Henry")var opt2:Option[String] = Noneprintln(opt1.get)*//* val f =(a:Int)=>{if(a>=0 && a<array.size){Some(array(a))}else{None}}val v :Option[Int]= f(2)if(v.isEmpty){println("NOTHING")}else{println(v.get)}*//*val pf:PartialFunction[Int, Int] = array.orElse({case x if (x%2 == 0) => 2*x})val v = pf(8)println(v)*//* val arr:Array[Int] =Array(1,2,3,4,1)val pf: PartialFunction[Int, Any] = arr.orElse({case ix if (ix >= 0 && ix < arr.length) => Some(arr(ix))case _=>None})println(pf(1))*///    修改***************************************************************************************//   array.update(2,20)//        array.foreach(println)//        array.updated(2,20).foreach(println)//         array.foreach(println)//交集，并集，差集//        val arr2=Array(3,4,5,6,12)//        val u = array union arr2//    val u = array ++ arr2//        val u = array intersect  arr2//        val u = array diff arr2//          val u = arr2 diff array//        u.foreach(println)//      val newArr= array:+11//      val newArr2=22+:newArr//    println(".......................")//      newArr.foreach(println)//        array.drop(2).foreach(println)//        array.foreach(println)//          array.dropRight(2).foreach(println)//        array.dropWhile((a:Int)=>a>5).foreach(println)//        array.foreach(println)//     val arr: Array[Int] = array.patch(2, Array(11,12,13,14), 2)//    val arr: Array[Int] = array.patch(2, GenSeq(), 2)//     arr.foreach(println)//逐个处理（迭代）************************************************************************************//        array.map((a:Int)=>(a+1)*2).foreach(println)//    array.reverseMap((a:Int)=>a).foreach(println)//    array.transform((a:Int)=>(a+1)*2).foreach(println)//        array.map(_*2).foreach(println)//val uArr:array[T]= 2DArr.flatten          //（扁平化，面向多维数组）降一个维度//      val uArr:array[T]= 2DArr.flatMap(f:Array[T]=>U)//降一个维度并处理//    val arr: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6))//    arr.foreach(println)//输出两个一维数组（输出对象）//    arr.flatten.foreach(println)//    arr.flatMap(t=>t.map(_*2)).foreach(println)//flatMap=flatten.map//    arr.flatten.map(_*2).foreach(println)//   val array:Array[Int] = Array(1,2,3,4,5,6,7,8,9)//分段|组************************************************************************************//    val parArr:ParArray[T] =array.par//并行数组（提供并行处理机制,开启线程，用来提速）（处理顺序改变）/* val array:Array[Int] = Array(1,2,3,4,5,6,7,8,9)val par: ParArray[Int] = array.parpar.map(_*1).foreach(println)*///    val tp2:(Array[T],Array[T])=array.partition(f:T=>Boolean)//按参数函数条件分为两个数组并封装成二元数组/*    val array:Array[Int] = Array(1,2,3,4,5,6,7,8,9)val t2: (Array[Int], Array[Int]) = array.partition(_ % 3== 0)t2.productIterator.foreach(it=>{ //productIterator:对元组类型的进行的迭代器val arr: Array[Int] = it.asInstanceOf[Array[Int]] //强制类型转换println(".................")arr.foreach(println)})*///    val it:Iterator[Array[T]]= array.grouped(size:Int)  //按指定每组元素数量分组//val it:Iterator[Array[T]]= array.sliding(size:Int,step:Int)//滑动分组（每组size个元素，每次步进step步，step默认为1）//flatten降维，group升维（升维目的是为了并行处理）//    val array:Array[Int] = Array(1,2,3,4,5,6,7,8,9)/* val it: Iterator[Array[Int]] = array.grouped(3)//    it.foreach(println)it.flatMap(_.map(_*2)).foreach(println)*///    array.sliding(3,2).flatMap(_.map(_*1)).foreach(println)//sliding滑动分组,默认sliding(3)=sliding(3,1)//    array.sliding(3,3).map(_.sum/3.0).foreach(println)   //sliding(3,3)=group(3)//    val map:Map(K,Array[T])= array.groupBy(key:K) //按键分组（T:为多元祖|样例类）（会导致数据倾斜/*val arr = Array((1, "java", 66), (1, "mysql", 76), (2, "java", 81), (2, "mysql", 72), (3, "java", 90))arr //过滤（科目数大于1），分组，求平均成绩.groupBy(_._1).filter(_._2.size>1).map(tp2=>(tp2._1,tp2._2.map(_._3).sum*1.0/tp2._2.size)).foreach(println)*//*val f=(arr:Array[(Int,String,Int)])=>{val sum=arr.map(_._3).sumval size =arr.size*1.0BigDecimal(sum/size,MathContext.DECIMAL32).setScale(2,RoundingMode.HALF_UP).doubleValue()}val arr = Array((1, "java", 66), (1, "mysql", 76), (2, "java", 81), (2, "mysql", 72), (3, "java", 90))arr //过滤（科目数大于1），分组，求平均成绩.groupBy(_._1).filter(_._2.size>1).map(tp2=>(tp2._1,f(tp2._2))).foreach(println)*///聚合*******************************************************************************************************val array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)//    val sum: Int = array.reduce((a:Int,b:Int)=>a+b)//显示reduce过程/* val sum: Int = array.reduce((a:Int,b:Int)=>{val c =a+bprintln(s"$a+$b=$c")c})*//* val sum: Int = array.reduceLeft((a:Int,b:Int)=>{val c =a+bprintln(s"$a+$b=$c")c})*//*val sum= array.reduceOption((a:Int,b:Int)=>{val c =a+bprintln(s"$a+$b=$c")c})println(sum)*//* val sum: Int = array.fold(10)((a:Int,b:Int)=>{val c =a+b
//       println(s"$a+$b=$c")c})println(sum)*//* val sum= array.scanLeft(0)((a:Int,b:Int)=>{val c =a+bprintln(s"$a+$b=$c")c})sum.foreach(println)*//*val array: Array[Int] = Array(1, 2, 3, 4, 5)val fm =(a:Int,b:Int)=>{val c =a+bprintln(s"map : $a+$b=$c")c}val fr =(a:Int,b:Int)=>{val c =a+bprintln(s"red : $a+$b=$c")c}//    val sum: Int = array.aggregate(0)(fm, fr)val sum: Int = array.par.aggregate(0)(fm, fr)println(s"sum = $sum")*///    println(array.sum)//    println(array.count((a:Int)=>a>5))//      println(array.max)//      println(array.min)//验证9****************************************************************************/*println(array.maxBy((a:Int)=>a))println(array.maxBy((a:Int)=>a*2))println(array.maxBy((a:Int)=>a>3))//返回满足条件的第一个数println(array.minBy((a:Int)=>a>5))//返回不满足条件的第一个数println(array.minBy((a:Int)=>(-a)))*///    println(array.isEmpty)//    println(array.nonEmpty)//    println(array.exists((a:Int)=>a>10))//    println(array.contains(10))//    println(array.containsSlice(GenSeq()))//(顺序要正确，空序列包含)//          println(array.containsSlice(GenSeq(1,2,4)))//=>false//    println(array.forall((a: Int) => a > 1))//        println(array.corresponds(GenSeq(0,1,2,3,4,5,6,7,8))((a: Int, b: Int) => a < b))//    println(array.sameElements(GenSeq(1,2,3,4,5,6,7,9,8)))//          println(array.startsWith(GenSeq()))//    println(array.startsWith(GenSeq(1,2,3)))//          println(array.endsWith(GenSeq()))//        println(array.endsWith(GenSeq(7,8,9)))//大小*******************************************************************************//    println(array.size)//    println(array.length)//    println(array.prefixLength((a: Int) => a >1))//    println(array.segmentLength((a: Int) => a <5,0))//        println(array.lengthCompare(6))//转变********************************************************************************************/*val copy = new Array[Int](5)array.copyToArray(copy, 2, 5)copy.foreach(println)*//*val sub = new Array[Int](5)array.copyToArray(sub, 2, 3)sub.foreach(println)*//*val buffer= new ArrayBuffer[Int]()array.copyToBuffer(buffer)buffer.foreach(println)*//*val bak = array.toArraybak.update(2,20)array.foreach(println)bak.foreach(println)*//*val set:Set[Int] = array.toSetset.foreach(println)*//*val distinct: Array[Int] = array.distinctdistinct.foreach(println)*//*val arr = Array(Array(1), Array(2), Array(3))
//    val arr = Array(1,2,3)val cp =arr.clonearr.foreach(println)println("===============")cp.foreach(println)*//*//    val arr = Array(Array(1), Array(2), Array(3))val arr = Array(1,2,3)val cp =arr.deeparr.foreach(println)println("===============")cp.foreach(println)*//*//    val arr = Array(Array(1), Array(2), Array(3))val arr = Array(1,2,3)val cp = arr.reprarr.foreach(println)println("===============")cp.foreach(println)*//*val map:Map[Int,Int]=Array((1,24),(2,43),(3,67),(4,3265)).toMapmap.foreach(print)*//*val stream=array.toStream//流包含第一个元素和剩余的所有的元素println(stream)println(stream.head)println(stream.indexOfSlice(GenSeq(),3))println(stream)println(stream.last)println(stream)*//*val newArr: Array[Int] = array.padTo(12, 0)println(newArr.mkString(","))*//* val tuple: (Array[Int], Array[Int]) = array.span((a: Int) => a < 4)array.span((a:Int)=>a>5).productIterator.foreach(item=>{item.asInstanceOf[Array[Int]].foreach(println)println("===")})*//*val t2: (Array[Int], Array[Int]) = array.splitAt(3)t2.productIterator.foreach(it=>{it.asInstanceOf[Array[Int]].foreach(println)println("====================")})t2._2.foreach(println)*//*val arr2d: Array[Array[Int]] = Array(Array(1, 2, 3), Array(4, 5, 6))arr2d.foreach(a=>println(a.mkString(",")))arr2d.transpose.foreach(a=>println(a.mkString(",")))*///    val array1: Array[(Int,String)] = Array((1,"a"),(2,"b"),(3,"c"),(4,"d"))//    val array2: Array[String] = Array("henry","pola","ariel","jack","rose")//    val array2: Array[String] = Array("henry","pola","ariel","jack","rose")//        val tps  = array1.zip(array2)//        val tps= array1.zipAll(array2,(0,"a"),"unknown")//        tps.foreach(println)/*  val tpArr: Array[(Int, String)] = array.zip(array2)val uz: (Array[Int], Array[String]) = tpArr.unzipuz._1.foreach(println)uz._2.foreach(println)*//*val tp3: (Array[Int], Array[String], Array[Int]) = Array((1, "henry", 18), (2, "pola", 16), (3, "ariel", 20)).unzip3tp3.productIterator.foreach(it=>{if(it.isInstanceOf[Array[Int]]){it.asInstanceOf[Array[Int]].foreach(println)}else{it.asInstanceOf[Array[String]].foreach(println)}})*///  array2.zipWithIndex.foreach(println)/*val uz: (Array[Int], Array[(Int, Int, Int, Int)]) = Array((1, 2, 3, 4, 5), (1, 2, 3, 4, 5), (1, 2, 3, 4, 5)).map(tp5 => (tp5._1, (tp5._2, tp5._3, tp5._4, tp5._5))).unzipuz._1.foreach(println)uz._2.foreach(println)
*///顺序（排序）****************************************************************************************//    array.reverseMap(e=>e+1).map(e=> e+1).map(a=>a+1)foreach(println)//    array.reverse.foreach(println)/*val it: Iterator[Int] = array.reverseIteratorit.foreach(e=>{println(s"$e+1")})var name = "zhangsan"var age = 15println(s"name=$name,age=$age")println(s"name=$name,${1+1}")*//*val a:Int=1234println(a)println(f"$a%d\t,1")*/////    array.sorted.reverse.foreach(println)//    array.sorted.reverseMap(a=>a*2).foreach(println)/* implicit val DESC= Ordering[Int].reverse  //隐式参数(类型匹配，自动调用（所以要精准匹配，类型最小化，严格控制数量）)array.sorted.foreach(println)*///    val ase = array.sortBy((a: Int) => a)
//    val ase= array.sortBy((a:Int)=> -a )
//    ase.foreach(println)
//        val asc = (a:Int) => a
//    array.sortBy(asc).foreach(println)//字符串拼接*******************************************************************************/*   println(array.mkString)println(array.mkString(","))println(array.mkString("[",",","]"))*///查找************************************************************************************************/*val array: Array[Int] = Array(3,1, 2, 5,6,7,8)
//    val index: Int = array.indexWhere((p: Int) => p > 5)val index= array.lastIndexWhere((p: Int) => p > 5)println(index)*//*    val array: Array[Int] = Array(3,1, 2, 5,6,7,8)val ix = array.indexOfSlice(GenSeq(5, 9, 4))println(ix)*///      val v= 1 to 10 by 2
//      println(v.getClass.getName)//      val array: Array[Int] = Array(3,1, 2, 5,6,7,8)
//      val rng: Range = array.indices
//      rng.foreach(println)}
}

scala array算子相关推荐

scala集合算子大全及分类汇总——倾心整理
++ 合并集合,返回新的数组 val arr1=Array(1,2,3) val arr2=Array(4,5,6) val arr3=arr1++arr2 arr3.foreach(println) ...
Scala Array中_ filter map的用法示例
object S {def main(args: Array[String]): Unit = {println("scala")val arr: Array[Int] = Arr ...
scala array 删除元素_Array中some介绍
概念 Array.prototype.some方法测试数组中是不是至少有1个元素通过了被提供的函数测试.它返回的是一个Boolean类型的值. 语法 arr.some(callback(element ...
Scala Array和List转ListBuffer
用to[ListBuffer]方法 scala> val l = List(1,2,3) l: List[Int] = List(1, 2, 3) scala> l.to[ListBuff ...
scala array和list互相转换
array有toList方法 list有toArray方法非常简单,方便
Scala Array sum recursive call
2021年大数据Spark（十六）：Spark Core的RDD算子练习
目录 RDD算子练习 map 算子 filter 算子 flatMap 算子交集.并集.差集.笛卡尔积 distinct 算子 first.take.top 算子 ...
Spark算子总结版
Spark的算子的分类从大方向来说,Spark 算子大致可以分为以下两类: 1)Transformation 变换/转换算子:这种变换并不触发提交作业,完成作业中间过程处理. Transformat ...
Spark RDD使用详解5--Action算子
本质上在Actions算子中通过SparkContext执行提交作业的runJob操作,触发了RDD DAG的执行. 根据Action算子的输出空间将Action算子进行分类:无输出. HDFS. ...

scala array算子

scala array算子相关推荐

最新文章

热门文章