scala array算子

最新推荐文章于 2023-03-17 16:51:18 发布
最新推荐文章于 2023-03-17 16:51:18 发布
阅读量427 收藏
点赞数
文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shixuefeng2410/article/details/123167343
版权

#算子（函数|方法）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.head
            val head = array.last
            println(head)*/

    /* val opt = array.headOption
         if (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)=>x
       case _=> -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.init
    while(!sub.isEmpty){
      println(sub.mkString(","))
      sub = sub.init
    }*/
    //求累加和
    /*  var sub: Array[Int] = array
  do {
     println(sub.sum)
     sub = sub.init
   } while(!sub.isEmpty)*/

    /*    var sub: Array[Int] = array
    do {
      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.lift
    val maybeInt :Option[Int]= lift(5)
    println(maybeInt)*/

    /*  var opt1:Option[String] = Some("Henry")
      var opt2:Option[String] = None
      println(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.par
      par.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).sum
      val size =arr.size*1.0
      BigDecimal(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+b
       println(s"$a+$b=$c")
       c
     })*/
    /* val sum: Int = array.reduceLeft((a:Int,b:Int)=>{
       val c =a+b
       println(s"$a+$b=$c")
       c
     })*/
    /*val sum= array.reduceOption((a:Int,b:Int)=>{
      val c =a+b
      println(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+b
       println(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+b
              println(s"map : $a+$b=$c")
              c
            }
            val fr =(a:Int,b:Int)=>{
              val c =a+b
              println(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.toArray
    bak.update(2,20)
    array.foreach(println)
    bak.foreach(println)*/

    /*val set:Set[Int] = array.toSet
    set.foreach(println)*/

    /*val distinct: Array[Int] = array.distinct
    distinct.foreach(println)*/

    /*val arr = Array(Array(1), Array(2), Array(3))
//    val arr = Array(1,2,3)
    val cp =arr.clone
    arr.foreach(println)
    println("===============")
    cp.foreach(println)*/

    /*//    val arr = Array(Array(1), Array(2), Array(3))
        val arr = Array(1,2,3)
        val cp =arr.deep
        arr.foreach(println)
        println("===============")
        cp.foreach(println)*/

    /*//    val arr = Array(Array(1), Array(2), Array(3))
        val arr = Array(1,2,3)
        val cp = arr.repr
        arr.foreach(println)
        println("===============")
        cp.foreach(println)*/

    /*val map:Map[Int,Int]=Array((1,24),(2,43),(3,67),(4,3265)).toMap
    map.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.unzip
   uz._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)).unzip3
    tp3.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)))
      .unzip
    uz._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.reverseIterator
    it.foreach(e=>{

      println(s"$e+1")
    })
    var name = "zhangsan"
    var age = 15
    println(s"name=$name,age=$age")
    println(s"name=$name,${1+1}")*/

    /*val a:Int=1234
    println(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)
  }
}

SXF2410
关注
《scala函数式编程》之List和Set
凌夜知惜
10-05 831
package com.lyzx.day20181005 /** * Scala 集合分为可变的和不可变的集合 * 默认情况下，Scala 使用的是不可变集合,如果你想使用可变集合,需要引用 scala.collection.mutable.Set包. * 默认引用 scala.collection.immutable._,不可变集合实例如下 */ class DataStru...
scala算子大全
abcdef_12a的博客
02-14 965
Array数组算子大全 次数数组 var array:Array[Int]=Array(1,2,3,4,5,6) 一、提取元素 1. array.foreach(f:(a:T)=>Uint) //遍历 ==参数传递的是函数 array.foreach(println) => 1 2 3 4 5 6 2.val rst:Int=array(index) //按照索引进行获取 println(array(1)) =...
scala的foreach和for
热门推荐
scalad
12-09 1万+
一句印象深刻的话，Alan Kay（Smalltalk发明者）说得一句话：“I’m not against types, but I don't know of any typesystems that aren't a complete pain, so I still like dynamic typing”。 并不是静态类型不好，只是静态类型的实现太让他痛苦了，所以他只好喜欢动态类型（语言
Scala学习——Array的方法实例 (完结+有序号方便学习)
Mr_Bright的博客
10-27 1122
Scala：Array(集合、序列) 数组是一种可变的、可索引的数据集合。在scala中用Array[T]的形式来表示Java中的数组形式 T[]。 val numbers = Array(1,2,3,4) //声明一个数组对象 val first = numbers(0) //读取第一个元素 numbers(3) = 100 //替换第四个元素为100、 val biggerNumbers = numbers.map(_ * 2) //所有元素乘2 Scala提供了大量的集合操作： (d
scala之reduce函数
qq_51903852的博客
12-02 1240
函数reduce 同flod，不需要初始值 格式 def reduce[A1 >: Int](op: (A1, A1) => A1): A1 数据 val a = Array(1,2,3,4,5) scala> a.reduce((x,y)=>{println(x,y,x+y);x+y}) (1,2,3) (3,3,6) (6,4,10) (10,5,15) res88: Int = 15 函数reduceLeft 格式 override def reduceLeft[B &g
Scala数组遍历：使用for和foreach
学亮编程手记
04-16 3007
使用匿名函数简化
Scala 计算算子
01-20
在Scala中，集合库是其核心部分之一，提供了丰富的操作符（计算算子）来处理各种集合，如List、Array、Set、Map、Range、Vector和Iterator等。这些算子使得集合的计算变得简单且高效。 首先，我们来看一下`sorted`...
Scala的集合算子
01-07
Scala集合提供了丰富的计算算⼦，⽤于实现集合/数组的计算，这些计算⼦⼀般针对于List、Array、Set、Map、Range、Vector、Iterator等都可以适⽤。 排序 ① sorted scala> var a = Array(1,3,4,2,5) a: Array[Int] = ...
scala的130个算子
chj1621802913的博客
01-10 371
一、元素操作 1、+: 定义：def +:(elem: A): Array[A] 描述：在数组前面添加一个元素，并返回新的数组对象，冒号的方向指向数组 示例： var a1=Array.range(1,5) a1.foreach(x=>print(x+"\t")) println() (12 +: a1).foreach(x=>print(x+"\t")) 1 2 3 4 在这里插入图片描述 2、:+ 定义：def :+(elem: A): Array[A] 描述：在数组后面添加一个元素，并返
Scala算子合集
RyougiShiki123的博客
07-20 301
Array Array的一些函数 1.创建一个一维数组一个二维数组用于测试 package scala object SelfTest { def main(args: Array[String]): Unit = { val array1 = Array(1,2,3,4,5,6,7,8,9,10) val array2 = Array(Array(123,456),Array(789,987),Array(654,321)) } } 2.函数 1°array1(index) &
Array reduce
Irene-li
11-14 514
Array.prototype.reduce() 按数组中某个值进行分组 let questions = [{ group: 'group1', title: 'question content 1' }, { group: 'group1', title: 'question content 2' }, { group: 'group1', t...
scala切片_Scala切片功能
从零开始的教程世界
07-17 7802
scala切片Today we will look into Scala slice function. 今天，我们将研究Scala slice功能。 斯卡拉切片 (Scala slice) Scala slice function is available in the following API classes: 以下API类中提供了Scala slice函数： Scala Array...
scala 中集合操作 slice take takeWhile tail head zip等操作
weixin_43548518的博客
12-25 1352
1）scala集合截取slice 的使用 //slice 按照指定角标截取集合的一部分，如下所示： val arr = Array(2,4,1,6,5,9,8) //[0,2) 0角标开始取到2角标 前包后不包，结果 2 4 val arr1: Array[Int] = arr.slice(0,2) //[2,5) 2角标开始取到5角标 前包后不包 结果 1 6 ...
Scala --- Array方法大全（一）
最新发布
qq_57151931的博客
03-17 2262
Scala --- Array方法大全
scala中的数组和集合操作
kang123488的博客
08-10 595
package kang /* 1.在scala集合中，Iterable是共同的Trait,Iterable要求继承者实现一些共同的方法，例如元素的遍历 * 2。Array是scala基础的数据结构，不从属于scala集合体系 * 3.scala集合分为可变和不可变集合。，不可变集合在scala.collection.immutable里，可变在scala.collection.mutable
Scala中Array方法大全
zp17834994071的博客
07-09 6261
Scala 数组 Scala 语言中提供的数组是用来存储固定大小的同类型元素。 声明数组变量并不是声明 num0、num1、…、num99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、…、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。 数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。 导包 使用数组方法之前要导包 import Array._ 声明数组 Scala 数组声明的语法格
Scala中reduceLeft和reduceRight解析
weixin_30746117的博客
06-12 246
转载于:https://www.cnblogs.com/drl-blogs/p/11086856.html
scala里面的drop和dropWhile
a_yyc1990的专栏
09-12 6009
drop & dropWhile drop丢弃前i个元素。 var numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) numbers = numbers.drop(5） println(numbers)                             //返回List(6,7,8,9,10) dropWhile移除前几个匹
Scala中Array算子总结
YYDS_emmm的博客
07-14 584
Scala中Array算子总结 提取元素 23 个 arr.foreach(f:t => Unit) //一个foreach可以解析一层（维）数据 val head: Int = arr.head //获取集合的第一个元素 arr空则报错 val last: Int = arr.last //获取集合的最后一个元素 arr空则报错 val head: Option[T] = arr.headOption //获取集合的第一个元素 arr空则返回None val last: Option[T] = a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值