scala学习之scala中一些集合的常用函数

scala学习

集合常用函数

集合的基本属性与常用操作

• 长度、大小、循环遍历、迭代器、生成字符串、是否有包含等

  object TestSetFunction {
    def main(args: Array[String]): Unit = {
      val list = List(1,2,3,4,5,6,7,8,9)
  
      // 长度
      println(list.length)
      // 集合大小
      println(list.size)
      //遍历
      list.foreach(println)
      // 迭代器
      for (item <- list){
        println(item)
      }
      // 生成字符串
      println(list.mkString(","))
      // 判断是否包含
      println(list.contains(5))
    }
  }
  /**
   输出结果为：
  9
  9
  1
  2
  3
  4
  5
  6
  7
  8
  9
  1
  2
  3
  4
  5
  6
  7
  8
  9
  1,2,3,4,5,6,7,8,9
  true
  **/
  

衍生集合的操作

• 这些操作基于原始集合生成新集合

  // 设置集合
      val numList=List(1,2,3,4)
      val abList = List(3,4,5,6)
  

  • 获取集合头/尾：

        // 获取集合头
        println(numList.head)
        // 获取集合尾（集合尾指出了集合头以外的全部元素
        println(numList.tail)
        // 集合的最后一个数据
        println(numList.last)
        // 集合的初始数据（除了最后一个数据
        println(numList.init)
    /**
    1
    List(2, 3, 4)
    4
    List(1, 2, 3)
    **/
    

  • 反转集合

        // 反转
        println(numList.reverse)
    /**
    List(4, 3, 2, 1)
    **/
    

  • 取（去）前（后）n个元素

        // 取前后n个元素
        println(numList.take(2))
        println(numList.takeRight(2))
        // 去掉前后n个元素
        println(numList.drop(2))
        println(numList.dropRight(2))
    /**
    List(1, 2)
    List(3, 4)
    List(3, 4)
    List(1, 2)
    **/
    

  • 交、并、差集

        // 并集
        println(numList.union(abList))
        // 交集
        println(numList.intersect(abList))
        // 差集
        println(numList.diff(abList))
    /**
    List(1, 2, 3, 4, 3, 4, 5, 6)
    List(3, 4)
    List(1, 2)
    **/
    

  • 拉链（PS：当两个集合的元素个数不相等的时候，会将同等数量的熟进行拉连，多余的数据省略不用

        // 拉链
        println(numList.zip(abList))
    /**
    List((1,3), (2,4), (3,5), (4,6))
    **/
    

  • 滑窗

        // 滑窗(第一个参数尾滑窗尺寸，第二个参数为步幅)
        val list = List(1,2,3,4,5,6,7,8,9)
        list.sliding(3,2).foreach(println)
    /**
    List(1, 2, 3)
    List(3, 4, 5)
    List(5, 6, 7)
    List(7, 8, 9)
    **/
    

集合计算的初级函数

• 一些对集合的计算的简单函数：

  object TestSetFunction2 {
    def main(args: Array[String]): Unit = {
      val list = List(1,2,3,4,5,-12)
      //求和
      println(list.sum)
      //求乘积
      println(list.product)
      //求最大值
      println(list.max)
      //最小值
      println(list.min)
      //排序
      // 按元素大小排序
      println(list.sortBy(x => x))
      // 按元素大小绝对值排序
      println(list.sortBy(x => x.abs))
      // 按元素大小升序降序
      println(list.sortWith((x,y) => x<y))
      // 按元素大小降序排列
      println(list.sortWith((x,y)=>x>y))
    }
  }
  /**
  3
  -1440
  5
  -12
  List(-12, 1, 2, 3, 4, 5)
  List(1, 2, 3, 4, 5, -12)
  List(-12, 1, 2, 3, 4, 5)
  List(5, 4, 3, 2, 1, -12)
  **/
  

集合计算高级函数

• 诸如过滤、映射、扁平化等一系列操作

  object TestAdvancedFunction {
    def main(args: Array[String]): Unit = {
      val list = List(1,2,3,4,5,6,7,8,9)
      val doubleList = List(List(1,2,3,4),List(5,6,7,8),List(9,10))
      val wordList = List("a b c","d e f g","12 13 14")
      // 过滤
      println(list.filter(x => x%2==0))
      //映射
      println(list.map(x=>x*10))
      // 扁平化
      println(doubleList.flatten)
      //扁平化加映射（PS：这种方法相当于先进行map操作然后进行flatten操作）
      println(wordList.flatMap(x=>x.split(" ")))
    }
  }
  /**
  List(2, 4, 6, 8)
  List(10, 20, 30, 40, 50, 60, 70, 80, 90)
  List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  List(a, b, c, d, e, f, g, 12, 13, 14)
  **/
  

• reduce方法

  reduce简化（规约）：通过指定的逻辑将集合中的数据进行聚合，从而减少数据最终获得结果

  • 从源码的角度来说，reduce其实就是调用了reduceLeft方法。

  object TestReduce {
    def main(args: Array[String]): Unit = {
      val list = List("1","2","3","4")
      val i = list.reduce((x,y)=>x+y)
      println(i)
  
      //reduceLeft和reduceRight
      println(list.reduceLeft((x,y)=>x+y))
      println(list.reduceRight((x,y)=>x+y))
    }
  }
  /**
  1234
  1234
  1234
  **/
  

• flod方法

  • flod就是一个带有初始值的reduce方法，他使用了函数柯里化，有两个参数列表
    • 第一个参数即为初始值
    • 第二个参数就是处理流程（处理方式）

  object TestFold {
    def main(args: Array[String]): Unit = {
      val list=List("a","b","c","d")
  
      println(list.fold("start")((x,y)=>x+y))
      // 与reduce类似的，flod本质上调用的flodLeft方法
      println(list.foldLeft("start")((x,y)=>x+y))
    }
  }
  /**
  startabcd
  startabcd
  **/
  

• 通过scala集合实现简单的wordCount

  • 思路，先用flatmap方法对每个字符串进行切分然后展开，再对每个相同单词进行归并
  • 然后对单词计数即可。

  object TestWordCount {
    def main(args: Array[String]): Unit = {
      val list = List("Just test a word count","word count","just a test","test a word count")
      // 首先将每个句子分隔成单词
      val l1=list.flatMap(x=>x.split(" "))
      // 相同单词合并
      val l2 = l1.groupBy(word => word)
      // 计数
      val l3 = l2.map(tuple => (tuple._1, tuple._2.size))
      // 对计数结果做排序
      val result = l3.toList.sortWith(
        (left, right)=>left._2 > right._2)
  
      // 输出结果
      println(result)
    }
  }
  /**
  List((test,3), (count,3), (a,3), (word,3), (just,1), (Just,1))
  **/
  

• 通过scala实现相对复杂的wordcount案例：

  • list中为一个一个的元组，元组中有两个元素，一个是一句包含一个以上单词的句子，第二个元素为一个整数，表示该句子出现的次数。
  • 实现思路，通过flatmap将每个元组中的句子单独裁开，统计出现次数后进行group操作，然后再进行reduce操作求和，得到结果。

  object TestWoedCount2 {
    def main(args: Array[String]): Unit = {
      val tuples = List(("Remilia Scarlet is best",3),("Remilia Scarlet and Frandre Scarlet are the sisters",2),("They are not twins",4))
      // 第一步，对每一个元组中的句子进行split并与出现次数相组合、获得一个词，次数的元组列表
      val words = tuples.flatMap{
        t => {
          val wordlist = t._1.split(" ")
          wordlist.map(word => (word,t._2))
        }
      }
      //按每个元组的词进行排序：
      words.sortBy(x => x._1)
      //相同单词进行归并
      val groups = words.groupBy(x => x._1)
      // 每个单词进行求和
      val resultMap = groups.map{
        x => {
          val word = x._1
          val value = x._2.reduce((a,b) => (a._1,a._2+b._2))
          (word,value)
        }
      }
      // 解除map嵌套并排序
      val result = resultMap.map(x=>x._2).toList.sortBy(-_._2)
      println(result)
    }
  }
  /**
  输出结果：
  List((Scarlet,7), (are,6), (Remilia,5), (They,4), (twins,4), (not,4), (is,3), (best,3), (Frandre,2), (sisters,2), (and,2), (the,2))
  **/
  

  • 以上过程可以免除过多变量的问题，直接写成：

  object TestWoedCount2 {
    def main(args: Array[String]): Unit = {
      val tuples = List(("Remilia Scarlet is best",3),("Remilia Scarlet and Frandre Scarlet are the sisters",2),("They are not twins",4))
      val result = tuples.flatMap{
        t => {
          val wordlist = t._1.split(" ")
          wordlist.map(word => (word,t._2))
        }
      }.sortBy(x => x._1)
        .groupBy(x => x._1)
        .map{
        x => {
          val word = x._1
          val value = x._2.reduce((a,b) => (a._1,a._2+b._2))
          (word,value)
        }
      }.map(x=>x._2).toList.sortBy(-_._2)
      println(result)
    }
  }
  /**
  输出结果同上
  **/
  

并行集合

• scala为了充分利用多核cpu，提供了并行集合，用于多喝环境的并行计算
• 语法：
  • 普通集合：(0 to 20).map{case _ => Thread.currentThread.getName}
  • 并行集合：(0 to 20).par.map{case _ => Thread.currentThread.getName}
  • 结果：
    • Vector(main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main, main)
    • ParVector(ForkJoinPool-1-worker-13, ForkJoinPool-1-worker-13, ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-3, ForkJoinPool-1-worker-7, ForkJoinPool-1-worker-7, ForkJoinPool-1-worker-5, ForkJoinPool-1-worker-5, ForkJoinPool-1-worker-5, ForkJoinPool-1-worker-11, ForkJoinPool-1-worker-11, ForkJoinPool-1-worker-1, ForkJoinPool-1-worker-1, ForkJoinPool-1-worker-1, ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-15, ForkJoinPool-1-worker-15, ForkJoinPool-1-worker-15)