Scala单词统计WordCount一般的和二元组拆分

小皮白

已于 2023-04-04 16:35:08 修改

阅读量629

点赞数

分类专栏： Scala学习文章标签： scala 大数据 hadoop

于 2023-04-04 16:32:05 首次发布

本文链接：https://blog.csdn.net/BS_GS/article/details/129955777

版权

Scala学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章展示了如何使用Scala进行单词统计，包括对字符串列表的拆分、扁平化、分组和计数操作，模拟Hadoop的MapReduce过程。同时，对比了两种不同的处理二元组形式的单词统计方法，强调学习编程需要耐心和理解。

摘要由CSDN通过智能技术生成

scala单词统计的过程，有Hadoop基础的同学应该能更好的理解，类似于mapreduce的过程。

复杂的（k,v）类型的List，流程，先拆分在统计或者先将相同的k统计组成一个新的二元组，再拆分。

先上一个简单的：

object Test17_CommonWordCount {
  def main(args: Array[String]): Unit = {
    val stringList: List[String] = List("hello scala", "hello redmi", "beautiful girl", "it is java", "learn spark")

    /*//拆分单词，按空格拆分
    val splitList: List[Array[String]] = stringList.map(_.split(" "))
    //flatten，扁平化，将嵌套结构打散
    val flatten: List[String] = splitList.flatten
    println(flatten)*/

    // 拆分单词简写，组成单词表
    val wordList = stringList.flatMap(_.split(" "))
    println(wordList)

    //以单词分组
    val stringToList: Map[String, List[String]] = wordList.groupBy(_ + "") //这里分组key是word，value也是word，_出错,和groupBy(_.2)不同

    //获取每组的长度，即每个单词的个数
    val countMap: Map[String, Int] = stringToList.map(kv => (kv._1, kv._2.length))

    //map转为List，sortWith做一个简单排序，按数量降序排列
    val list: List[(String, Int)] = countMap.toList.sortWith(_._2 > _._2)
    println(list)
  }
}

对于最后的输出结果做一个取前三的操作，在最后加一个 .take(3) 的操作即可

//将map转换为list，取前三
    val list: List[(String, Int)] = countMap.toList.sortWith(_._2 > _._2).take(3)   //转为list，在对其排序输出
    println(list)

接着上一个复杂的，二元组形式的单词统计

object Test18_ComplexWordCount {
  def main(args: Array[String]): Unit = {
    val tupleList: List[(String, Int)] = List(
      ("hello scala", 1),
      ("hello redmi", 2),
      ("beautiful girl", 2),
      ("it is java", 1),
      ("learn spark", 2),
      ("hello spark from spark", 2))

    //----------------方法一：转为普通的形式
    //拆分单词
    val stringList: List[String] = tupleList.map(
      kv => (kv._1 + " ") * kv._2
    )

    println(stringList)

    val wordList: List[(String, Int)] = stringList
      .flatMap(_.split(" ")) //空格分词
      //      .groupBy(word => word)
      .groupBy(_ + "") //按照单词分组
      .map(kv => (kv._1, kv._2.size)) // 统计个数
      .toList
      .sortBy(_._2)(Ordering[Int].reverse) //相比于sortWith节省资源
    //      .sortWith(_._2 > _._2)
    println(wordList)
    println("======================================")


    //--------------------方法二：基于预统计的结果进行转换
    //将字符串打散，并结合对应的个数组合成新的二元组
    val preCountList: List[(String, Int)] = tupleList.flatMap(
      tuple => {
        val value: Array[String] = tuple._1.split(" ")
        println("value: " + value.mkString)
        value.map(word => (word, tuple._2)).reverse
      }
    )
    println("preCountList: " + preCountList)
    //对二元组按照单词进行分组
    val preCountMap: Map[String, List[(String, Int)]] = preCountList.groupBy(tuple => tuple._1)
    println(preCountMap)

    val countMap: Map[String, Int] = preCountMap.mapValues(
      newTupleList => newTupleList.map(_._2).sum
    )

    println(countMap)

    val countList: List[(String, Int)] = countMap.toList.sortBy(_._2)(Ordering[Int].reverse)
    println(countList)
  }
}

各位，学海无涯，着急不来，慢慢体会吧。

ps：有人问我Scala是跟谁学的，我是跟着尚硅谷学的。