Scala常用函数

基本属性和常用操作

1)说明
(1)获取集合长度
(2)获取集合大小
(3)循环遍历
(4)迭代器
(5)生成字符串
(6)是否包含
2)案例实操

package chapter07

object Test11_CommonOp {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val list = List(1,3,5,7,13)
    val set = Set(23,34,423,75)

    //获取集合的长度
    println(list.length)

    //获取集合的大小
    println(list.size)
    println(set.size)

    //循环遍历
    for (elem <- list)
      println(elem)

    set.foreach(println)

    //迭代器
    for (elem <- list.iterator)
      println(elem)

    //生成字符串
    println(list)
    println(list.mkString("-"))
    println(set)
    println(set.mkString("-"))


  }

}

衍生集合

1)说明
(1)获取集合的头
(2)获取集合的尾(不是头的就是尾)
(3)集合最后一个数据
(4)集合初始数据(不包含最后一个)
(5)反转
(6)取前(后)n 个元素
(7)去掉前(后)n 个元素
(8)并集
(9)交集
(10)差集
(11)拉链
(12)滑窗
2)案例实操

package chapter07

object Test12_DerivedCollection {
    
    

  def main(args: Array[String]): Unit = {
    
    

    val list1 = List(1,2,3,4 )
    val list2 = List(1,2,3,4,5,6,7,8)

    //获取集合的头
    println(list1.head)
    println(list2.head)

    //获取集合的尾,除了头之外的
    println(list1.tail)
    println(list2.tail)

    //获取最后一个元素
    println(list2.last)

    //集合的初始元素(不包括最后一个)
    println(list2.init)

    //反转
    println(list1.reverse)

    //取前(后)n个元素
    println(list1.take(3))
    println(list1.takeRight(3))

    //去掉前(后)n个元素
    println(list1.drop(1))
    println(list1.dropRight(1))
    println(list1)  //并不改变原来的集合

    //并集
    val union = list1.union(list2)
    println(union)
    println(list1 ::: list2)

    //如果是set做并集,会去重
    val set1 = Set(1,2,3,4 )
    val set2 = Set(1,2,3,4,5,6,7,8)

    val union2 = set1.union(set2)
    println(union2)
    println(set1 ++ set2)

    //交集
    val intersection = list1.intersect(list2)

    println(intersection)

    //差集
    val diff1 = list2.diff(list1)
    val diff2 = list1.diff(list2)

    println(diff1)
    println(diff2)

    //拉链(变成二元组),一方多的部分直接删除
    println(list1.zip(list2))
    println(list2.zip(list1))

    //滑窗,括号内为滑动的距离,即单个list的长度
    for (elem <- list1.sliding(2))
      println(elem)

    //滑窗,括号内为滑动的距离,以及下次滑动间隔距离,即单个list的长度,
    for (elem <- list1.sliding(2,2)) //这种也叫做滚动窗口
      println(elem)
  }

}

集合计算简单函数

1)说明
(1)求和
(2)求乘积
(3)最大值
(4)最小值
(5)排序

  • sorted :对一个集合进行自然排序,通过传递隐式的 Ordering
  • sortBy :对一个属性或多个属性进行排序,通过它的类型。
  • sortWith :基于函数的排序,通过一个 comparator 函数,实现自定义排序的逻辑。

2)案例实操

package chapter07

object Test13_SimpleFunction {
    
    
  def main(args: Array[String]): Unit = {
    
    

    val list = List(1,2,3,4,5,19,7)
    val list1 = List(("a",1),("b",2),("c",3), ("d",1))

    //求和
    var sum = 0
    for (elem <- list){
    
    
      sum += elem
    }
    println(sum)

    //自带方法
    println(list.sum)

    //求乘积
    println(list.product)

    //求最大值
    println(list.max)
    println(list1.max) //对于元组默认只比较第一个

    println(list1.maxBy((tuple : (String,Int) ) => tuple._2)) //指定按照第二个比较
    println(list1.maxBy(_._2)) //上面的简化


    //求最小值
    println(list.min)

    //求排序(从小到大)
    println(list.sorted)

    val sortedlist = list.sorted
    println(sortedlist)

    //求排序(从大到小)

    println(list.sorted.reverse)
    //或者下面的
    val sortedlist1 = list.sorted(Ordering[Int].reverse)
    println(sortedlist1)

    //sortBy

    println(list1.sortBy(_._2)) //默认从小到大
    println(list1.sortBy(_._2)(Ordering[Int].reverse)) //从大到小


    //sortWith
    println(list.sortWith((a: Int, b : Int) => {
    
    a < b}))
    println(list.sortWith( _ < _)) //简写

  }

}

集合计算高级函数

1)说明
(1)过滤
遍历一个集合并从中获取满足指定条件的元素组成一个新的集合
(2)转化/映射(map)
将集合中的每一个元素映射到某一个函数
(3)扁平化
(4)扁平化+映射 注:flatMap 相当于先进行 map 操作,在进行 flatten 操作
集合中的每个元素的子元素映射到某个函数并返回新集合
(5)分组(group)
按照指定的规则对集合的元素进行分组
(6)简化(归约)
通过指定的逻辑将集合中的数据进行聚合,从而减少数据,最终获取结果。
(7)折叠
Fold折叠:化简的一种特殊情况。
2)案例实操

package chapter07
  object Test14_HighLevelFunction_Map {
    
    

    def main(args: Array[String]): Unit = {
    
    

      val list = List(1,2,3,4,5,6,7)
      val map1 = Map("a"->3, "b"-> 5, "c"->7)
   	  val map2 = mutable.Map("a"->6, "b"-> 8, "c"->10,"d"-> 12)

      //过滤操作

      //选取偶数
      val evenlist = list.filter((elem : Int) => {
    
    elem % 2 == 0})
      println(evenlist)


      val evenlist1 = list.filter((_ % 2 == 0)) //上面的简化

      //选取奇数
      val evenlist2 = list.filter((_ % 2 == 1)) //上面的简化
      println(evenlist2)


      //转化、映射操作  map
      //把集合中每个数字乘以2
      println(list.map(_ * 2 ))

      //把每个元素转换为平方
      println(list.map(x => x * x )) //不可再简化了

      //扁平化
      val nestedList: List[List[Int]] = List(List(1,2,3), List(4,5),List(6,7))

      val flatList = nestedList(0) ::: nestedList(1) ::: nestedList(2)  //扁平化,打散,放到一个里面
      println(flatList)

      val flatList2 = nestedList.flatten  //这个更好
      println(flatList2)

      //扁平映射
      //将一组字符串进行分词,并保存成单词的列表

      val strings : List[String] = List("hello java", "hello scala", "hello spark", "all study")
      val splitList: List[Array[String]] = strings.map(_.split(" "))  //分词
      val flattenList = splitList.flatten  //打散扁平化
      println(flattenList)


      //上面简化
      val flatmapList = strings.flatMap(_.split(" "))
      println(flatmapList)


      //分组groupBy
      //分成奇偶两组
      val groupMap = list.groupBy(_ % 2)
      val groupMap2 = list.groupBy( data => {
    
    if (data % 2 == 0) "偶数" else "奇数"})

      println(groupMap)
      println(groupMap2)

      //给定一组词汇,按照分词的首字母进行分组
      val wordList = List("china", "america","alice","bob","canada")
      println(wordList.groupBy(_.charAt(0)))

 	  println(map1 ++ map2)
    //相同的字母添加(合并两个map里面数值)
     val map3 = map1.foldLeft(map2)((mergemap,kv) => {
    
    
      val key = kv._1
      val value = kv._2

      mergemap(key) = mergemap.getOrElse(key,0) + value
      mergemap
    })
    println(map3)

    }
  }

猜你喜欢

转载自blog.csdn.net/weixin_44480968/article/details/119504674

相关文章