Scala之高级函数

悠悠 2022-12-28 14:15 130阅读 0赞

# Scala之高级函数 #

package com.scala.charpter07
    
    object $12_LowFunction { 
      
      def main(args: Array[String]): Unit = { 
      
        val list = List(10,2,5,3,7,90,20)
        println(list.min)
        println(list.max)
        println(list.sum)
      
        
        //根据指定规则获取最大值
        val list2 = List(("zhangsan",20,5000),("lis",25,1200),("wangwu",12,5000))
        println(list2.maxBy(_._3))
        println(list.minBy(x => x))
      
      
        //排序（默认升序）
        println(list.sorted)
        //降序排序
        println(list.sorted.reverse)
      
      
        //按照指定规则排序
        val list5 = List(("zhangsan",20,5000),("lis",25,1200),("wangwu",12,5000),("aa",55,500),("aa",23,6000))
        println(list5.sorted)
        println(list5.sortBy(_._3))
        println(list5.sortBy(_._3).reverse)
      
        //指定排序规则【升序/降序】
        println(list.sortWith( (x,y)=>x>y  )  )
        println(list.sortWith(_ < _))
      
      
        //filter:过滤
        //filter（func:集合元素类型=>Boolean） 保留函数返回值为true的数据
        //filter是针对集合的每个元素进行操作
        println(list.filter(_ % 2 == 0))
      
        
        //map：转换数据类型或者格式
        //应用场景：map是针对一对一场景，val B = A.map() ,此时B集合的长度=A集合的长度
        //map(func:集合元素类型=>U)
        //map中的函数针对集合每个元素进行操作
        println(list.map(x => (x, 1)))
      
      
        //flatten：压平
        //应用场景：flatten是针对一对多场景，val B = A.flatten，此时B集合长度大于等于A集合长度
        val list3 = List[List[String]](
          List("spark","scala"),
          List("java","python"),
          List("flume","kafka")
        )
        println(list3.flatten)
      
      
        //flatmap = map + flatten
        //flatmap（func：集合元素类型 =>集合）
        //场景：一对多,在对数据转换的同时需要压平，就使用flatmap
        val list4 = List("hello java hello","spark scala")
      
        println(list4.map(_.split(" ")).flatten)
        println(list4.flatMap(_.split(" ")))
        
      
        //foreach(func: 集合元素类型 => B):Unit
        //foreach中函数是针对集合中每个元素进行操作
        list4.foreach(println)
      
      
      
        //groupby分组（多对一）
        //groupBy是按照指定的字段/规则分组
        //groupBy(func: 集合元素类型 => U )
        //groupBy中的函数是针对集合每个元素进行操作
        //groupBy的结果是Map,Map的key就是分组的key,value就是分组key在原集合中key对应的元素集合
        val list7 = List( ("zhangsan",20,"男"),("lisi",30,"女"),("wangwu",22,"男"))
        println(list7.groupBy(_._3))
      
      
        println(list)
      
        
        
        
        //reduce（func：（集合元素类型，集合元素类型）=>集合元素类型）
        //reduce是两两聚合，用上一次的聚合结果和当前元素进行计算
        //reduce计算是从左往右
        println(list.reduce(_ + _))
        var r1= list.reduce( (x,y)=>{ 
          
          println(s"x=${x} y=${y}")
          x+y
        } )
        println(r1)
      
      
      
        //reduceRight
        //从右向左计算
        //agg: 上一次的计算结果
        //curr: 当前要计算的元素
        println("*"*100)
        val r2 = list.reduceRight( (curr,agg)=>{ 
          println(s"agg=${agg} curr=${curr}")
          agg-curr
        } )
        println(r2)
      
      
      
      
        //fold
        //fold与reduce的区别：第一次计算的初始值需要自己赋值
        println("*"*10)
        list.fold(1000)((x,y)=>{ 
          
          println(s"x=${x} y=${y}")
          x+y
        })
      
        
        
        //foldright
        //foldright与reduceright的区别：第一次计算的初始值需要自己赋值
        println("*"*10)
        list.foldRight(200)((x,y)=>{ 
        
          println(s"x=${x} y=${y}")
          x+y
        })
      
      
      
      
      
      
      
      
      
      }
      
      
      
    }