scala的常见函数与方法(一)

定义与书写格式

函数的完整定义 (本质是一个引用类型)

 val func:(Int,Int) =>Int =(x:Int,y:Int)=>x+y

返回元组的函数

val func2: (Int , Double) =>(Double, Int) = (x ,y) => (y, x)

简写

 val f2 = (x :Int ,y :Double) => (y,x)
f2: (Int, Double) => (Double, Int) = $Lambda$1011/487964833@52bd9a27

无参无返回函数

 val f :() =>Unit =() =>("HelloWord")

函数的下划线简写

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

正常写
scala> arr.map(a => a*10)
res0: Array[Int] = Array(10, 20, 30, 40, 50)

_简写
scala> arr.map(_ * 10) 
res3: Array[Int] = Array(10, 20, 30, 40, 50)

_不能单独使用    ( _ )是错误的

在元组中调用时( _._1 , _._2.length)这样是不行的,逗号隔开这代表是两个参数,前面是a参数,后面跟着b参数的长度,这显然不是我们需要的

reduce 聚合函数

其可以配合math函数

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.reduce((x,y) => x+y)
res6: Int = 15

_ 划线简写
scala> arr.reduce(_+_)
res7: Int = 15



两者比较取最值

arr.reduce( Math.min(_ ,_) )

arr.reduce( Math.max(_ ,_) )

 reduceLeft 从左向右聚合

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.reduceLeft(_ -_)
res10: Int = -13
运行过程
1
1-2
(1-2)-3
((1-2)-3)-4
...

reduceRight从右向左聚合

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.reduceRight(_ - _)
res12: Int = 3

right的减法顺序是先拿出两个,然后左减右
4-5
3-(4-5)
2-(3-(4-5))
1-(2-(3-(4-5)))

 fold聚合函数

fold 与reduce相似,多了个初始值

arr.fold(0)(_ + _)与arr.sum结果一致

arr.fold(1)(_ * _)与arr.product

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.fold(100)(_+_)
res9: Int = 115
注意初始值的数据类型 第一个括号内就是初始值

foldLeft

scala> val arr =List(("a",1),("a",2),("b",2),("b",3),("c",5))
arr: List[(String, Int)] = List((a,1), (a,2), (b,2), (b,3), (c,5))

scala> arr.groupBy( _._1 ).map(a => (a._1,a._2.foldLeft(0)(_ + _._2)))
res16: scala.collection.immutable.Map[String,Int] = Map(b -> 5, a -> 3, c -> 5)

mapValues

将values进行map操作,再跟key组成元组

val lines = Array("spark,hadoop,flink,spark", "spark,flink,spark,hadoop,hive", "spark,flink,hive")
       
    //将数组按","切开,并炸开数组,然后小写并分组
    val grouped: Map[String, Array[String]] = lines.flatMap(_.split(",")).groupBy(_.toLowerCase)

    //将values进行map操作，再跟key组合成一个元组
    val wordAndCount: Map[String, Int] = grouped.mapValues(_.length)

    print(wordAndCount)


Map(hadoop -> 2, spark -> 5, flink -> 3, hive -> 2)

sorted 排序

arr.sorted  对可以排序的集合元素可以直接调用       

arr.sorted.reverse 降序 

对不可以排序的集合元素的不行,需要传入比较器        Ordering

val res4 = ls2.sorted(new Ordering[Student02] {
      override def compare(x: Student02, y: Student02): Int = -(y.age-x.age)
    })

sortBy 排序

对于一些自定义元素,需要简单的维度排序是较为方便

val ls1  = List[Student](
      Student(3,"zss",23) ,
      Student(2,"lss",45) ,
      Student(1,"lny" ,34)
    )
//指定排序字段    排序优先级大于自定义类所重写的排序规则
val res = ls1.sortBy(_.name).reverse
//对于数值类型 可以使用 负号 - 倒序排序
val res2 = ls1.sortBy(- _.age)

 sortWith 排序

arr.sortWith(( a , b ) =>  a > b)   降序排序 

arr.sortWith(( a, b ) =>  a < b)  升序   

arr.sortWith( _  > _ )   降序

arr.sortwith( _ < _ )  升序

arr.sortWith(( a , b ) => a.compareTo(b) > 0 )   降序        两者比较

arr.sortWith(( a , b ) => a.compareTo(b) < 0 )   升序

forEach 遍历

map比其多了返回值

遍历,无返回值,常用于打印

val arr = Array(1,2,3,4,5)

arr.forEach(println)

map 遍历

适用于list,set,map,array,但元组中没有map函数

遍历有返回值,但可不返

map遍历没有偏函数,collect中可以传入偏函数        

        偏函数:  用来处理集合中的某一种数据类型

 collect  遍历

val arr = Array(1,2,3,4,5,"hello" ,"jim" , true)
    /** 定义一个偏函数
     * 偏函数:用来处理集合中的某一种数据类型
     * PartialFunction 接口
     * [Any , Int] 输入的是Any  Int是要处理的类型
     */
    val f = new PartialFunction[Any, Int] {
      override def isDefinedAt(x: Any): Boolean = {
        x.isInstanceOf[Int]
      }

      override def apply(v1: Any): Int = v1.asInstanceOf[Int] * 10
    }

arr.collect(f).foreach(println)
arr.collect(f).filter(_ > 30 ).foreach(println)

filter 过滤

过滤集合的方法  遍历集合中的每个元素  符合条件的返回true 返回true的元素 收集起来返回新的集合

val ls: immutable.Seq[Any] = List(1,2,3,4,"java","scala")
//配合守护模式与推导式使用
val ints: immutable.Seq[Int] = for (elem <- ls if elem.isInstanceOf[Int]) yield elem.asInstanceOf[Int] * 10

// 连续使用多次filter进行条件过滤
val map = Map[String,Int](("zss" ,91),("zww",89),("zzx",92) , ("ww",23))
map.filter(_._1.startsWith("z")).filter(_._2>90)

//多条件filter进行条件过滤
val ls = "spark":: "scala" :: "c++"::"java"::1::2::12.34::Nil
// 过滤出选过滤出String类型的和Double类型的数据
ls.filter{
  case i:String => true
  case i:Int=>false
  case i:Double=>true
} 

filterNot 过滤拿到与之不同的内容

与filter极其相似,只是过滤出来的是反值

flatten 压平

将一个集合中的集合压平,展开,组成一个新的集合

flatMap 先遍历在压平

map+flatten方法的组合 ,先遍历集合中的每个元素 , 再按照指定的规则压平, 返回压平后的新的集合

grouped     分组

按照指定个数进行分组

val  list1 = List(1,2,3,4,5,6,7,8,9,10,11)
    // 每三个数为一组  求和
    val iterator: Iterator[List[Int]] = list1.grouped(3)  // 每组几个元素
    iterator.map(ls=>ls.sum).foreach(println)

groupBy 分组

可以指定元素分组,按照条件分组

val  list1 = List(1,1,1,2,3,3,4,4)
val list2 = List("scala" , "is" , "option" , "fucntion")
val mp = Map[String,Int]("a"->1,"b"->1,"c"->2)
val ls = List(("a",1),("a",1),("a",1),("a",1),("b",1),("b",1))

//  指定某个元素
val res2: Map[Int, Map[String, Int]] = mp.groupBy(_._2)
// 条件分组  
val res3: Map[Boolean, List[String]] = list2.groupBy(_.contains("s"))
val res4: Map[Boolean, List[Int]] = list1.groupBy(_ > 2)
val res5: Map[String, List[(String, Int)]] = ls.groupBy(_._1)

mkString 字符串拼接

将集合中的元素进行拼接   

val ls = List[String]("tom" , "jim" , "jack" ,"rose" ,"naiyuan")

//效果一样
val str: String = ls.reduce(_ +":"+ _)
val str1: String = ls.mkString(":")

take 取值

arr.take(n)  从左向右取n个

arr.takeRight(n)   从右向左取n个

takeWhile 取值到条件不符结束

val arr = Array(5,10,7,1,3,2,4,8,6,9)

val res3 = arr.takeWhile(_ > 1)

值:ArrayBuffer(5, 10, 7)

aggregate  相当于是sum之类

val arr = Array(5,10,7,1,3,2,4,8,6,9)

arr.aggregate(0)( _ + _ , _ * _)  默认值 与后面的无关,没用上