Scala-19：复杂的WordCount案例

素颜马尾好姑娘i 2023-10-04 16:54 9阅读 0赞

## Scala-19：复杂的WordCount案例 ##

### 一、案例分析 ###

简单的案例中传进来的数据全是字符串，如下所示：

List(
          "hello",
          "hello world",
          "hello scala",
          "hello spark from scala",
          "hello flink from scala"
        )

如果传进来的数据并不全是字符串，而是经过一次统计的数据，比如

List(
          ("hello",1),
          ("hello world",2),
          ("hello scala",3),
          ("hello spark from scala",1),
          ("hello flink from scala",2)
        )

那么这个处理过程就会稍微复杂一点，就要考虑每个单词后面次数的问题，通常的处理方式有两种

#### 1：第一种 ####

**直接展开为普通版本**

("hello world",2) => ("hello world hello world")

**变成了普通的版本之后，就和之前简单的WordCount案例的处理流程一样了**

#### 2：第二种 ####

**基于预统计的结果进行转换**

("hello world",2) => ("hello", 2), ("world", 2)

**按照二元组的单词分组**

("hello" => ("hello", 1), ("hello", 2), ("hello", 3), ("hello", 1), ("hello", 2))

**叠加每个单词预统计的数值**

("hello", 9)

### 二、所用方法 ###

所使用的方法和简单案例中的相似，只是不同的处理方式中，所需要的map阶段输出类型不同

#### 1：将列表打散为每个单词+个数 flatMap ####

List[(String, Int)] => List[(String, Int)]

#### 2：叠加每个单词预统计的数值 ####

Map[String, Lsit[(String, Int)]] => Map[(String, Int)]

### 三、代码实现 ###

#### 1：直接展开为普通版本 ####

object ComplexWordCount {
        
      def main(args: Array[String]): Unit = {
        
    
        val stringList: List[(String, Int)] = List(
          ("hello",1),
          ("hello world",2),
          ("hello scala",3),
          ("hello spark from scala",1),
          ("hello flink from scala",2)
        )
    
        //思路1：直接展开为普通版本
        val newStringList: List[String] = stringList.map(
          kv => {
        
            (kv._1.trim + " ") * kv._2
          }
        )
    
        //打散
        val groupMap: Map[String, List[String]] = newStringList.flatMap(_.split(" ")).groupBy(word => word)
        val countMap: Map[String, Int] = groupMap.map(kv => (kv._1, kv._2.length))
        //排序
        val sortMap: List[(String, Int)] = countMap.toList.sortWith(_._2 > _._2)
        println(sortMap)
        //取前三
        val preList: List[(String, Int)] = sortMap.take(3)
        println(preList)
      }
    
    }

#### 2：基于预统计的结果进行转换 ####

object ComplexWordCount {
        
      def main(args: Array[String]): Unit = {
        
    
        val stringList: List[(String, Int)] = List(
          ("hello",1),
          ("hello world",2),
          ("hello scala",3),
          ("hello spark from scala",1),
          ("hello flink from scala",2)
        )
    
        //1.将列表打散为每个单词+个数
        val proCountList: List[(String, Int)] = stringList.flatMap(
          tuple => {
        
            val strings: Array[String] = tuple._1.split(" ")
            strings.map(word => (word,tuple._2))
          }
        )
    
        //2.按照二元组单词进行分组
        val preCountMap: Map[String, List[(String, Int)]] = proCountList.groupBy(_._1)
        println(preCountMap)
    
        //3.叠加每个单词预统计的个数值
        val countMap: Map[String, Int] = preCountMap.map(
          tupleList => (tupleList._1, tupleList._2.map(_._2).sum)
    
        )
    
        //4.转换为list，排序，取前三
        val sortList: List[(String, Int)] = countMap.toList.sortWith(_._2 > _._2).take(3)
        println(sortList)
    
      }
    
    }

### 四、两种方法的区别 ###

第一种方法就是将单词乘以预统计的结果，得到的就是全字符串的数据，最后的处理方式就是和简单案例的一样，其严格来说最后的统计不能算是完全的聚合

而第二种方法则是借助预统计的结果，在最后根据每个单词的预统计结果进行聚合，是真正意义上的聚合操作，这样的做法是推荐的，形同于MapRedue的阶段。