Scala实现wordcount单词计数

原创 于 2025-08-19 12:22:02 发布 · 553 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#scala #windows #wpf

单词计数：将集合中出现的相同的单词，进行计数。

基础的wordcount

        基础的wordcount中，我们只需要对包含字符串的List[String]进行单词计数即可。

        我们要对这个List进行wordcount：

val stringList: List[String] = List(
  "hello",
  "hello scala",
  "hello spark scala",
  "hello flink scala",
  "hello java",
  "darren"
)

流程分析

  • 首先，我们需要将这个stringList中每一个String元素按照空格拆分为单词数组Array[String]，得到一个 List[Array[String]] ，然后将这些 List[Array[String]] 进行扁平化处理，得到拆分后的 List[String] ：
//将List中字符串按照空格拆分为Array[String]数组
val stringList1: List[Array[String]] = stringList.map(string => string.split(" "))

//将stringList1进行扁平化
val stringList2: List[String] = stringList1.flatten

这两步操作可以通过flatmap进行简化，将map和flat合并到一步进行：

//将list按照空格拆分后进行扁平化
val stringList12: List[String] = stringList.flatMap(string => string.split(" "))

  • 然后我们将得到的扁平化List按照字符串聚合，形成一个 String -> List[String] 的Map映射，这个Map的元素为 单词 -> 当前单词全部出现的列表 ：
//将stringList2依据单词本身进行聚合，得到string -> List[String]的map
val stringList3 = stringList2.groupBy(string => string)
println(stringList3)

  • 接着，我们按照得到的映射，统计每个List中的元素，形成一个 String -> Int 的Map映射，这个Map映射的元素为 单词 -> 出现次数 ：
//将stringList3进行map统计，变成一个(字符 -> 出现次数)的Map
val countMap = stringList3.map((kv: (String, List[String])) => (kv._1, kv._2.size))
println(countMap)

  • 最后，我们将这个映射转换成 List[(String, Int)] 的集合，按照 Tuple._2 进行降序排列，取出前三个元素形成结果集合即可，这个集合的元素为 (单词, 出现次数)的二元组 ：
//将countMap转化为List[Map]，并且降序排序取出前三个元素
val wordCount: List[(String, Int)] = countMap.toList.sortWith((kv1, kv2) => kv1._2 > kv2._2).take(3)
println(wordCount)

简单wordcount函数展示

基于上述流程可以构建一个简单wordcount函数：

//简单wordcount函数
def simpleWordCount(list: List[String]): List[(String, Int)] = {
  list
    .flatMap(elem => elem.split(" "))
    //对list进行按照空格拆分 & 扁平化处理
    
    .groupBy(elem => elem)
    //按照字符串元素的聚合，形成string -> List[String]的Map
    //  比如: Map(("a" -> List["a", "a", "a"]), ("b" -> List["b", "b", "b"]))
    
    .map(kv => kv._1 -> kv._2.size)
    //按照List.size（出现次数）进行统计，形成String -> Int的Map
    //  比如：Map(("a" -> 3), ("b", -> 4))
  
    .toList.sortWith((kv1, kv2) => kv1._2 > kv2._2).take(3)
    //形成List[(String, Int)],按照出现次数进行降序排序，并且取出前三个元素，将该结果直接返回
}

 复杂的wordcount

         现在我们有一个已经进行预统计的单词集合，这个集合已经标记了每个字符串出现的次数（可以理解为分布式文本统计结果的初步聚合），我们需要对其进行进一步的单词计数，统计每一个单词总共出现的次数：

//预统计字符串出现次数元组
val stringList: List[(String, Int)] = List(
  ("hello", 1),
  ("hello scala", 2),
  ("hello spark scala", 3),
  ("hello flink scala", 2),
  ("hello java", 1),
  ("darren", 9)
)

       我们很容易想到将这个List按照字符串出现次数进行拼接，转换为普通List，然后按照简单wordcount那样进行单词计数：

//简单wordcount函数
def simpleWordCount(list: List[String]): List[(String, Int)] = {
    //对list进行按照空格拆分 & 扁平化处理
  list.flatMap(string => string.split(" ")).
    //对stringList进行按照字符串元素的聚合，形成string -> List[String]的Map
    //  比如: Map(("a" -> List["a", "a", "a"]), ("b" -> List["b", "b", "b"]))
    groupBy(string => string).
    //将groupMap按照List.size（出现次数）进行统计，形成String -> Int的Map
    //  比如：Map(("a" -> 3), ("b", -> 4))
    map(kv => kv._1 -> kv._2.size).
    //将countMap形成List[(String, Int)],按照出现次数进行降序排序，并且取出前三个元素，将该结果直接返回
    toList.sortWith((kv1, kv2) => kv1._2 > kv2._2).take(3)
}
//将预统计字符串变为普通字符串
//  即将每个字符串按出现次数进行拼接
val strings1 = stringList.map(kv => (kv._1 + " ") * kv._2)
println(strings1)
val result1 = simpleWordCount(strings1)
println(result1)

流程分析

       但是这种方式浪费了预统计处理，并没能成功利用。我们在这里提供一种基于预统计结果进行处理的wordcount：

  • 原始List的元素是 (String, Int) 的一系列Tuple2，我们可以对String进行拆分，然后根据出现次数Int，将Tuple拆分为 Array[(String, Int)] ，对其进行扁平化合并，实现按照空格拆分单词同时又能利用预统计结果：
//根据预统计对每一个字符串进行拆分，得到一个(String, Int)元组数组，然后进行扁平化
//  比如("hello scala", 2)，拆分后结果为：Array(("hello", 2), ("scala", 2))
val list = stringList.flatMap(tuple => {
  val stringArr: Array[String] = tuple._1.split(" ")
  stringArr.map(elem => elem -> tuple._2)
})
println(list)

  • 然后对于新的扁平化集合，我们就可以按照Tuple._1进行分组，将相同单词的元组划分到一类，得到 String -> List[(String, Int)] 的Map，其中的 List[(String, Int)] 为当前单词以及出现次数的元组，在分布式场景中可以理解为多个文件中的单词出现情况：
//对这个元组List按照tuple._1进行分组聚合，形成一个string -> List[(String, Int)]的map
//  比如：对hello有关元组进行聚合，得到：hello -> List[("hello", 1), ("hello", 2)]
val groupList = list.groupBy(tuple => tuple._1)
println(groupList)

  • 对于这个Map，我们就可以对 List[(String, Int)] 进行求和，获取该单词的出现次数了。我们可以使用map方法，对于Map中每一个kv，将其转换成kv._2中的tuple._2的和：
//对groupList中每一组kv进行value的合并，得到String -> Int的结果，并排序，取出前三
val resultList = groupList.map(kv => {
  //统计每个单词出现的次数
  //  可以通过kv._2的List[(String, Int)]调用map，获取List中元组的第二个元素，然后进行求和
  //  即：kv._2.map(tuple => tuple._2).sum
  kv._1 -> kv._2.map(tuple => tuple._2).sum
})
println(resultList)

  1. 我们对这个处理过程进行参数说明。groupList.map(kv => ) 中的kv是分组Map的每一个元组，这个元组是 (String, List[(String, Int)]) 类型的。比如：scala -> List((scala,2), (scala,3), (scala,2))。
  2. 我们需要将kv._2 （即 List[(String, Int)]） 进行求和转换，就需要对kv._2再进行一次map操作，即：kv._2.map(tuple => tuple._2).sum 。这个操作中的tuple就是kv._2中的 (String, Int) 元组，我们对这个 kv._2 转换成只包含 Int 的List，比如：List((scala,2), (scala,3), (scala,2)) 转换成 List(2, 3, 2)。
  3. 最后我们构建 String -> Int 的映射，即：kv._1 -> kv._2.map(tuple => tuple._2).sum ，也就是 当前单词 -> 在所有文档出现次数 的映射。
  • 最后我们进行 toList 转换，构建成有序集合，然后根据 出现次数（tuple._2） 进行sortWith排序，最后 使用 take 取出前三即可：
val result = resultList.toList.sortWith((kv1, kv2) => kv1._2 > kv2._2).take(3)
println(result)

复杂wordcount函数展示

    def complexWordCount(list: List[(String, Int)]): List[(String, Int)] = {
      list
        .flatMap(tuple => tuple._1.split(" ").map(string => string -> tuple._2))
        //对每一个元组的字符串都进行拆分，得到Array[String]数组，
        // 对该数组进行map处理，将元素与元组出现次数一起，得到Array[(元组中单词, 元组中单词出现次数)]，
        //  比如：("hello scala", 2) -> Array(("hello", 2), ("scala", 2))
        // 并将Array进行扁平化
        // 结果为：
        // List((hello,1), (hello,2), (scala,2), (hello,3), (spark,3),
        //    (scala,3), (hello,2), (flink,2), (scala,2), (hello,1),
        //    (java,1), (darren,9)
        //  )

        .groupBy(tuple => tuple._1)
        //按照单词进行分组，得到 单词 -> List[该单词所有出现的元组] 的Map映射
        // 结果为：
        // Map(darren -> List((darren,9)), java -> List((java,1)), flink -> List((flink,2)),
        //    spark -> List((spark,3)), scala -> List((scala,2), (scala,3), (scala,2)),
        //    hello -> List((hello,1), (hello,2), (hello,3), (hello,2), (hello,1))
        // )

        .map(kv => kv._1 -> kv._2.map(tuple => tuple._2).sum)
        //对分组Map进行转换，得到 单词 -> 出现总次数的Map映射
        //  kv即分组Map集合的键值对 单词 -> List[该单词所有出现的元组]
        //  kv._1为当前单词
        //  kv._2为List[该单词出现的所有元组]
        //  kv._2.map(tuple => tuple._2)就是将kv._2转换成只有单词出现次数的List

        .toList.sortWith((kv1, kv2) => kv1._2 > kv2._2).take(3)
        //将 单词 -> 出现总次数的Map映射构建成有序集合List，
        // 按照出现次数kv._2进行降序排列，
        // 然后取前三名
    }
    println(complexWordCount(stringList))

陌名_
关注
使用scala语言实现wordcount程序
weixin_43740680的博客
07-28 829
使用scala语言实现wordcount（统计单词出现的次数）： object WordCount { def main(args: Array[String]): Unit = { val lines = List("hadoop hive spark scala","spark hive habase", "hive spark java") //数据转换 ...
spark实现 wordcount 单词计数
qq_36213530的博客
07-05 876
需求： 单词计数，将集合中出现的相同的单词，进行计数，取计数排名前三的结果 代码实现： val tupleList1 = List(("Hello Scala Spark World ", 4), ("Hello Scala Spark", 3), ("Hello Scala", 2), ("Hello", 1)) //0).将元组(字符串，次数) 进行转换为一个大的字符串 val newList: List[String] = tupleList1.map(kv =&gt
Scala语言进阶(二)：单词计数WordCount案例
小M呀~之大数据系列
05-18 2152
Scala语言进阶案例
五种方式实现WordCount单词计数的小案例
qq_37001101的博客
10-27 1655
Java实现WordCount 思路：首先建立map集合----将文件按行读取------按规则进行拆分-----循环遍历放入map集合中。如果集合中没有元素就将单词与数字1放进去，如果集合中存在要添加的内容就将value+1覆盖原来的内容。 import java.io.*;import java.util.HashMap;import java.util.Map;public cla...
Scala-代码实现WordCount案例
SmallScorpion
04-11 640
需求 // 单词计数：将集合中出现的相同的单词，进行计数，取计数排名前三的结果 val stringList = List("Hello Scala Hbase kafka", "Hello Scala Hbase", "Hello Scala", "Hello") 需求分析 代码实现 def main(args: Array[String]): Unit = { // 单词计数：将集...
Spark Core：Scala单词计数
一顿吃不饱的博客
11-11 3248
Spark Core：Scala单词计数 1、实验描述 利用Scala语言开发Spark WordCount程序 实验时长： 45分钟 主要步骤： 创建spark项目 编写wordcount 示例程序 运行Scala 程序 查看实验结果 2、实验环境 虚拟机数量：3(一主两从，主机名分别为：master、slave01、slave02) 系统版本：Centos 7.5 Hadoop版本：Apache Hadoop 2.7.3 Spark版本：Apache Spark 2.1.1 JDK 版本：1.8.
scala的WordCount案例
汉子一枚
02-15 830
WordCount案例 接下来，我们要使用Actor并发编程模型实现多文件的单词统计。 案例介绍 给定几个文本文件（文本文件都是以空格分隔的），使用Actor并发编程来统计单词的数量 思路分析 实现思路 MainActor获取要进行单词统计的文件 根据文件数量创建对应的WordCountActor 将文件名封装为消息发送给WordCountActor WordCountActor接收消息，并统计...
Scala语言实现WordCount案例以及几个高级函数的使用总结
m0_38109926的博客
09-20 795
Scala语言实现WordCount案例以及几个高级函数的使用总结 实现案例前需要熟悉scala中集合的几个高级函数： 映射：**集合.map() ** 即拿到集合中元素做某些处理，返回当前集合的类型。 扁平化：**集合.flatten() **就是提取外层集合中的内层集合中的元素，打散放入到外层集合中。 映射和扁平化可以写成一个函数：集合.flatMap()。 分组：**集合.groupBy()**函数：根据集合中元素的某个特征进行分组，返回值类型：Map(any -> List[any]) 排序
Scala +Spark+Hadoop+Zookeeper+IDEA实现WordCount单词计数（简单实例-上）
David的博客
11-13 672
                 IDEA+Scala +Spark实现wordCount单词计数-上 一、新建一个Scala的object单例对象，修改pom文件 （1）下面文章可以帮助参考安装 IDEA 和 新建一个Scala程序。 IntelliJ IDEA（最新）安装-破解详解--亲测可用 Intellij IDEA+Maven+Scala第一个程序 （2）pom文件 <...
如何使用IDEA工具开发一个WordCount单词计数程序？.docx
03-22
最后，使用`reduceByKey`对相同单词的计数进行累加，然后遍历结果并打印。 4. **运行和测试** 完成代码编写后，可以在IDEA中运行`WordCount`对象的`main`方法。由于我们设置了`setMaster("local[2]")`，程序将在...
如何使用IDEA工具开发一个WordCount单词计数程序？.pdf
03-22
使用IDEA工具开发一个WordCount单词计数程序 IDEA是一种功能强大且广泛使用的集成开发环境（Integrated Development Environment），它提供了多种语言的开发支持，其中包括Scala语言。Spark是基于Scala语言开发的...
Scala面试题及详细答案100道（11-20）-- 函数式编程基础
大剑师兰特的GIS世界
08-16 839
本文介绍了Scala中函数式编程的核心概念，包括高阶函数、匿名函数、闭包以及常用集合操作函数。高阶函数允许将函数作为参数或返回值，实现代码抽象和复用。匿名函数（Lambda表达式）提供简洁的函数定义方式，适用于临时函数逻辑。闭包能捕获外部变量，延长变量生命周期。文章详细讲解了map、flatMap、filter等集合操作函数的区别与用法，以及foldLeft、foldRight和reduce三种聚合函数的特点和使用场景。这些特性体现了Scala强大的函数式编程能力，适用于数据处理、集合操作等开发需求。
Kafka下载和安装
qq_43494013的博客
08-14 225
Kafka下载和安装
spark+scala安装部署
更深兼春远的博客
08-18 400
目录，这是由于 Spark 的事件日志（Event Log）功能配置了 HDFS 路径，但该路径不存在导致的。报错：问题出在 Spark 无法找到 HDFS 上的。因此在hdfs上创建目录，为了方便赋予权限。启动master进程，jps查看。修改spark-env.sh。传完记得分别source刷新。启动worker节点。
Java 中表示数据集的常用集合类
最新发布
qq_39460057的博客
08-18 226
Java 集合框架提供了多种数据结构来表示和操作数据集，每种集合类都有其特定的用途和性能特征。
用 FreeMarker 动态构造 SQL 实现数据透视分析
nbsaas-boot基于Request-Response的企业级快速开发框架
08-15 335
摘要：本文介绍了一种基于FreeMarker模板的动态SQL生成方案，用于实现ERP/BI系统中的数据透视分析功能。该方案通过配置化维度、指标和过滤条件，支持灵活的多维分组统计，同时采用白名单机制（字段映射、聚合函数限制）和参数绑定保证SQL安全性。FreeMarker模板负责SQL结构，Java代码处理输入校验和SQL片段生成，实现了安全、可扩展的数据透视分析引擎，适用于销售、库存等多种业务场景。
标准电子邮件地址格式（RFC 5322 里的 mailbox 语法）
时间不说谎
08-15 321
是一个人类可读的名字，通常用引号包裹以避免空格、特殊字符冲突。如果名字里没有特殊字符，引号可以省略。这是实际的电子邮件地址。
Java进阶学习之Stream流的基本概念以及使用技巧
freed_Day的博客
08-14 400
摘要：Java8 Stream流是函数式数据处理API，通过管道操作高效处理集合数据。其核心特点包括无存储、函数式风格、延迟执行和链式调用。Stream由数据源、中间操作（filter/map/sorted等）和终端操作（collect/forEach等）组成。使用流程：先创建流（集合/数组/直接创建），再链式调用中间操作进行过滤/映射/排序等，最后执行终端操作获取结果。实战技巧包括避免嵌套循环、使用并行流加速处理、短路优化及分组分区等。合理使用Stream可使代码简洁性提升50%以上，但需注意流的一次性消
Python开篇：2024全链路指南，从入门到架构解锁未来
ztt123654的博客
08-18 676
能力进化路径阶段技能要求初级语法基础、脚本编写中级框架使用、测试驱动开发高级系统设计、性能优化架构师分布式架构、技术决策2025趋势预测Python在物联网设备上的Wasm移植类型系统支持更复杂的泛型编程")---🔥🔥🔥道阻且长,行则将至,让我们一起加油吧！
scala语言实现单词计数
05-11
以下是使用Scala实现单词计数的示例代码： ```scala import scala.io.Source object WordCount { def main(args: Array[String]) { if (args.length < 1) { println("Usage: WordCount <file>") System.exit(1) } val filename = args(0) var count = 0 for (line <- Source.fromFile(filename).getLines()) { count += line.split("\\W+").filter(!_.isEmpty).length } println(s"Total number of words: $count") } } ``` 这个程序接受一个文件名作为命令行参数，并计算文件中单词的总数。它使用Scala的Source对象从文件中读取行，然后使用正则表达式将每行分割成单词，并过滤掉空字符串。最后，使用累加器计算单词数量并输出结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值