编程基础

Scala 版｜第 2 版

Spark

本书以 Scala 作为开发 Spark 应用程序的编程语言，系统地介绍了 Spark 编程的基础知识。全书共 9 章，

内容包括大数据技术概述、Scala 语言基础、Spark 的设计与运行原理、Spark 环境搭建和使用方法、

RDD 编程、Spark SQL、Spark Streaming、Structured Streaming 和 Spark MLlib。

本书每章都安排了入门级的编程实践操作，以便使读者能更好地学习和更牢固地掌握 Spark 编程方法。

本书配套官网免费提供了全套的在线教学资源，包括讲义 PPT、习题、源代码、软件、数据集、授课视频、

上机实验指南等。

本书可以作为高等院校计算机、软件工程、数据科学与大数据技术等专业的进阶级大数据课程教材，用于

指导 Spark 编程实践，也可供相关技术人员参考。

SPARK PROGRAMMING

WITH SCALA

(2ND)

编

程

基

础

编程基础

Scala 版｜第 2 版

大数据创新人才

培养系列

大数据创新人才培养系列

林子雨 赖永炫 陶继平 ◎ 编著

名校名师打造大数据领域精品力作

Spark

微课视频

附

深入浅出，零基础入门 Spark 编程实践

贴近实战，结合实例，详细介绍 Spark 编程基础知识

Scala版｜第

2

版Spark

扫此二维码下载

本书配套资源

教材服务热线：010-81055256

反馈／投稿／推荐信箱：315@ptpress.com.cn

人邮教育服务与资源下载社区：www.ryjiaoyu.com

FM59501(大数据创新)Spark编程基础 （Scala版 第2版）（附微课视频）.indd 1-3 2022/12/19 下午6:08

内 容 提 要

本书以 Scala 作为开发 Spark 应用程序的编程语言，系统地介绍 Spark 编程的基础知识。本书共

9 章，内容包括大数据技术概述、Scala 语言基础、Spark 的设计与运行原理、Spark 环境搭建和使用

方法、RDD 编程、Spark SQL、Spark Streaming、Structured Streaming 和 Spark MLlib。

本书安排入门级的编程实践操作，以便读者能更好地学习和更牢固地掌握 Spark 编程方法。本书

免费提供全套的在线教学资源，包括 PPT、习题、源代码、软件、数据集、授课视频、上机实验指

南等。

本书可以作为高等院校计算机科学与技术、软件工程、数据科学与大数据技术等专业大数据课

程的教材，用于指导学生进行 Spark 编程实践，也可以供相关技术人员参考。

♦ 编 著 林子雨 赖永炫 陶继平

责任编辑 孙 澍

责任印制 王 郁 陈 犇

♦ 人民邮电出版社出版发行 北京市丰台区成寿寺路 11 号

邮编 100164 电子邮件 315@ptpress.com.cn

网址 https://www.ptpress.com.cn

三河市祥达印刷包装有限公司印刷

♦ 开本：787×1092 1/16

印张：18 2022 年 12 月第 2 版

字数：438 千字 2022 年 12 月河北第 1 次印刷

定价：65.00 元

读者服务热线：(010)81055256 印装质量热线：(010)81055316

反盗版热线：(010)81055315

广告经营许可证：京东市监广登字 20170147 号

《Spark 编程基础（Scala 版）》第 1 版于 2018 年 7 月出版，至今已经过去了 4 年多的时间。

IT 发展的步伐从来没有停止，在过去的 4 年多时间里，Spark 的版本在不断升级，性能在不断

提升，其在企业界的应用也在不断深入。与此同时，与 Spark 有强竞争关系的 Flink 技术也在

迅速成长、壮大，使 Spark 面临强有力的挑战。Flink 是一款能够实现毫秒级响应并且支持“精

确一次”一致性、高吞吐、高性能的流计算框架，同时它还支持批处理。就像 Spark 一样，Flink

也形成了完备的生态系统，可以为企业提供一站式服务，大大降低了大数据技术人员的开发难

度，也降低了企业开发大数据平台的成本。与 Flink 相比，Spark 的短板在于无法满足毫秒级

的企业实时数据分析需求。Spark 的流计算组件 Spark Streaming 的核心思路是将流数据分解

成一系列短小的批处理作业，每个短小的批处理作业都可以使用 Spark Core 进行快速处理。

但是，Spark Streaming 在实现了高吞吐和容错性的同时，牺牲了低延迟和实时处理能力，最

快只能满足秒级的实时计算需求，无法满足毫秒级的实时计算需求。由于 Spark Streaming 组

件的延迟较高，最快响应速度只能达到秒级，因此它无法满足一些需要更快响应速度的企业应

用的需求。为此，Spark 社区又推出了 Structured Streaming。Structured Streaming 是一种

基于 Spark SQL 引擎构建的、可扩展且可容错的流处理引擎，可以实现更快的响应速度。

为了配合 Spark 技术升级，也为了更好满足高等院校教师的教学需求，我们对本书第 1 版

进行了改版。本书第 2 版的内容变化主要包括以下几个方面：

（1）采用 Spark 3.2.0 版本，所有代码根据新版本进行修订；

（2）增加一些对 RDD 常用操作的介绍，如 distinct、union、intersection、subtract 和

zip 等；

（3）对介绍 Spark SQL 的章节做了较多修改，增加对编写 Spark SQL 独立应用程序和编

译打包方法的介绍，增加对数据抽象 DataSet 的介绍，介绍 RDD、DataFrame 和 DataSet 之

间的关系，并给出 DataSet 编程实例；

（4）增加对新组件 Structured Streaming 的详细介绍，并给出一些编程实例。

需要指出的是，虽然 Spark 官网推荐用户从 RDD 编程转到 DataFrame 和 DataSet 编程，

但是考虑 RDD 编程有其独特的应用场景，有些问题用 RDD 编程来解决具有更好的灵活性，

前言 FOREWORD

2

因此，本书第 2 版保留了介绍 RDD 编程的内容。此外，虽然按照 Spark 官网的说法，Spark

Streaming 将逐渐被 Structured Streaming 取代，但是目前很多企业应用场景还是可以继续使

用 Spark Streaming（毕竟很多企业应用不需要毫秒级的响应速度），因此，本书第 2 版保留了

介绍 Spark Streaming 的内容。

本书共 9 章，详细介绍 Spark 的环境搭建和基础编程方法等。

第 1 章是大数据技术概述，帮助读者对大数据技术形成总体认识以及了解 Spark 在其中所

扮演的角色。

第 2 章介绍 Scala 语言基础，为读者学习基于 Scala 语言的 Spark 编程奠定基础。

第 3 章介绍 Spark 的设计与运行原理。

第 4 章介绍 Spark 环境搭建和使用方法，为读者开展 Spark 编程实践铺平道路。

第 5 章介绍 RDD 编程，包括 RDD 的创建、操作 API、持久化、分区及键值对 RDD 等，

这一章的知识是读者开展 Spark 高级编程的基础。

第 6 章介绍 Spark 中用于结构化数据处理的组件 Spark SQL，包括 DataFrame 及其创建

方法和基本操作等。

第 7 章介绍 Spark Streaming，这是一种构建在 Spark 上的流计算框架，可以满足对流式

数据进行实时计算的需求。

第 8 章介绍 Structured Streaming，它是一种基于 Spark SQL 引擎构建的、可扩展且可

容错的流处理引擎，具有较好的实时性。

第 9 章介绍 Spark 的机器学习库 MLlib，包括 MLlib 的基本原理、算法、模型选择和超参

数调整方法等。

本书由林子雨、赖永炫和陶继平编著。其中，林子雨负责全书规划、统稿、校对和在线资

源创作，并撰写第 1、3、4、5、6、7、8 章的内容；陶继平负责撰写第 2 章的内容；赖永炫负

责撰写第 9 章的内容。在撰写过程中，厦门大学计算机科学与技术系硕士研究生陈绍纬、周伟

敬、阮敏朝、刘官山、黄连福、周凤林、吉晓函等做了大量的辅助性工作，在此，向这些同学

表示衷心的感谢。同时，感谢夏小云老师在书稿校对过程中的辛勤付出。

本书免费提供全部配套资源的在线浏览和下载，并接受错误反馈和发布勘误信息。同时，

前言

3

Spark 作为大数据进阶课程的内容，读者在学习过程中会涉及大量的大数据基础知识以及各种与

大数据相关的软件的安装和使用，因此，推荐读者访问厦门大学数据库实验室建设的高校大数据

课程公共服务平台来获得必要的辅助学习内容。

笔者在撰写本书的过程中，参考了大量的网络资料和相关图书，对 Spark 技术进行系统梳

理，有选择地把一些重要知识纳入本书。由于笔者能力有限，本书难免存在不足之处，望广大

读者不吝赐教。

林子雨

厦门大学数据库实验室

2022 年 11 月

第 1 章 大数据技术概述 ........... 1

1.1 大数据的概念与关键技术.................1

1.1.1 大数据的概念.................................. 1

1.1.2 大数据关键技术.............................. 2

1.2 代表性大数据技术 ..........................3

1.2.1 Hadoop ............................................ 3

1.2.2 Spark ............................................... 6

1.2.3 Flink................................................. 9

1.2.4 Beam..............................................11

1.3 编程语言的选择............................12

1.3.1 不同编程语言简介 ........................12

1.3.2 Spark 开发语言对比..................... 13

1.4 在线资源 .....................................14

1.5 本章小结 .....................................14

1.6 习题............................................14

实验 1 Linux 操作系统的安装和常用

命令 .......................................15

第 2 章 Scala 语言基础 ........ 17

2.1 Scala 语言概述............................17

2.1.1 计算机的缘起................................ 17

2.1.2 编程范式........................................18

2.1.3 Scala 简介......................................19

2.1.4 Scala 的安装..................................20

2.1.5 编写及运行 HelloWorld 程序......21

2.2 Scala 基础知识............................22

2.2.1 基本数据类型和变量 ....................22

2.2.2 I/O ..................................................25

2.2.3 控制结构........................................26

2.2.4 数据结构........................................30

2.3 面向对象编程基础 ........................35

2.3.1 类....................................................35

2.3.2 对象................................................40

2.3.3 继承................................................44

2.3.4 参数化类型.................................... 47

2.3.5 特质................................................ 49

2.3.6 模式匹配........................................ 52

2.3.7 包.................................................... 55

2.4 函数式编程基础............................56

2.4.1 函数的定义与使用........................ 56

2.4.2 高阶函数........................................ 57

2.4.3 闭包................................................ 58

2.4.4 偏应用函数和柯里化.................... 59

2.4.5 针对容器的操作............................ 60

2.4.6 函数式编程实例............................ 65

2.5 本章小结 .................................... 66

2.6 习题........................................... 66

实验 2 Scala 编程初级实践 .................67

第 3 章 Spark 的设计与运行

原理........................ 71

3.1 概述............................................71

3.2 Spark 生态系统 ...........................72

3.3 Spark 运行架构 ...........................74

3.3.1 基本概念........................................ 74

3.3.2 架构设计........................................ 74

3.3.3 Spark 运行基本流程 .................... 75

3.3.4 RDD 的设计与运行原理............... 77

3.4 Spark 的部署模式 ........................85

3.5 TensorFlowOnSpark................. 86

3.6 本章小结 .....................................87

3.7 习题............................................87

第 4 章 Spark 环境搭建和使用

方法........................88

4.1 安装 Spark................................. 88

4.1.1 基础环境........................................ 88

4.1.2 下载安装文件................................ 89

目录 CONTENTS

2

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

4.1.3 配置相关文件................................90

4.1.4 Spark 和 Hadoop 的交互.............90

4.2 在 spark-shell 中运行代码 ...........91

4.2.1 “spark-shell”命令 .....................91

4.2.2 启动 spark-shell ..........................92

4.2.3 Spark 用户界面 ............................92

4.3 开发 Spark 独立应用程序..............93

4.3.1 安装编译打包工具 ........................93

4.3.2 编写 Spark 应用程序代码............94

4.3.3 编译打包........................................95

4.3.4 通过“spark-submit”命令

提交并运行程序............................ 97

4.4 Spark 集群环境搭建.....................98

4.4.1 集群概况........................................98

4.4.2 搭建 Hadoop 集群.........................98

4.4.3 在集群中安装 Spark ....................99

4.4.4 配置环境变量................................99

4.4.5 Spark 的配置 ................................99

4.4.6 启动 Spark 集群 ........................ 100

4.4.7 关闭 Spark 集群 .........................101

4.5 在集群上运行 Spark 应用程序 .....101

4.5.1 启动 Spark 集群 .........................101

4.5.2 在集群中运行应用程序 JAR 包 ...101

4.5.3 在集群中运行 spark-shell ........101

4.5.4 查看应用程序的运行情况 ..........102

4.6 本章小结 ...................................102

4.7 习题..........................................102

实验 3 Spark 和 Hadoop 的安装 .......103

第 5 章 RDD 编程.............. 105

5.1 RDD 编程基础...........................105

5.1.1 RDD 创建.....................................105

5.1.2 RDD 操作.....................................106

5.1.3 持久化..........................................113

5.1.4 分区..............................................114

5.1.5 一个综合实例..............................118

5.2 键值对 RDD ..............................120

5.2.1 键值对 RDD 的创建....................120

5.2.2 常用的键值对 RDD 转换操作....120

5.2.3 一个综合实例..............................126

5.3 数据读写 ...................................126

5.3.1 本地文件系统的数据读写.......... 127

5.3.2 HDFS 的数据读写...................... 129

5.3.3 读写 MySQL 数据库 .................. 129

5.4 综合实例 ...................................132

5.4.1 求 Top N 个数据的值 ................ 132

5.4.2 文件排序...................................... 133

5.4.3 二次排序...................................... 134

5.5 本章小结 ...................................135

实验 4 RDD 编程初级实践 ................136

第 6 章 Spark SQL........... 139

6.1 Spark SQL 简介........................139

6.1.1 从 Shark 说起............................. 139

6.1.2 Spark SQL 的架构 .....................140

6.1.3 为什么推出 Spark SQL ............. 141

6.1.4 Spark SQL 的特点 ..................... 142

6.1.5 Spark SQL 简单编程实例 ......... 142

6.2 结构化数据 DataFrame..............144

6.2.1 DataFrame 概述......................... 144

6.2.2 DataFrame 的优点..................... 145

6.3 DataFrame 的创建和保存...........145

6.3.1 Parquet ....................................... 146

6.3.2 JSON............................................ 146

6.3.3 CSV.............................................. 147

6.3.4 文本文件...................................... 148

6.3.5 序列集合...................................... 148

6.4 DataFrame 的基本操作..............149

6.4.1 DSL 语法风格............................. 149

6.4.2 SQL 语法风格............................. 151

6.5 从 RDD 转换得到 DataFrame.....153

6.5.1 利用反射机制推断 RDD 模式.... 153

6.5.2 使用编程方式定义 RDD 模式.... 154

6.6 使用 Spark SQL 读写数据库.......156

6.6.1 准备工作...................................... 156

6.6.2 读取 MySQL 数据库中的

数据 ............................................. 157

6.6.3 向 MySQL 数据库写入数据 ...... 158

6.6.4 编写独立应用程序访问

MySQL........................................ 159

6.7 DataSet ...................................160

目 录

3

6.7.1 DataFrame、DataSet 和 RDD 的

区别..............................................160

6.7.2 创建 DataSet...............................162

6.7.3 RDD、DataFrame 和 DataSet

之间的相互转换..........................163

6.7.4 词频统计实例..............................165

6.8 本章小结 ...................................165

6.9 习题..........................................165

实验 5 Spark SQL 编程初级实践.......166

第 7 章 Spark Streaming... 168

7.1 流计算概述................................168

7.1.1 静态数据和流数据 ......................168

7.1.2 批量计算和实时计算 ..................169

7.1.3 流计算概念..................................170

7.1.4 流计算框架..................................170

7.1.5 流计算处理流程 ..........................171

7.2 Spark Streaming ......................172

7.2.1 Spark Streaming 简介...............172

7.2.2 Spark Streaming 与 Storm 的

对比..............................................173

7.2.3 从 Hadoop+Storm 架构转向

Spark 架构..................................173

7.3 DStream 操作概述.....................175

7.3.1 Spark Streaming 工作机制.......175

7.3.2 编写 Spark Streaming 程序的

基本步骤......................................175

7.3.3 创建 StreamingContext 对象 ...175

7.4 基本数据源................................176

7.4.1 文件流..........................................176

7.4.2 套接字流......................................178

7.4.3 RDD 队列流.................................182

7.5 高级数据源................................183

7.5.1 Kafka 简介..................................184

7.5.2 Kafka 准备工作 ..........................184

7.5.3 Spark 准备工作 ..........................185

7.5.4 编写 Spark Streaming 程序

使用 Kafka 数据源.....................185

7.6 转换操作 ...................................189

7.6.1 DStream 无状态转换操作 .........189

7.6.2 DStream 有状态转换操作......... 189

7.7 输出操作 ...................................192

7.7.1 把 DStream 输出到文本

文件中 ......................................... 192

7.7.2 把 Dstream 输出到关系

数据库中 ..................................... 193

7.8 本章小结 ...................................195

7.9 习题..........................................195

实验 6 Spark Streaming 编程初级

实践......................................196

第 8 章 Structured

Streaming............ 197

8.1 概述..........................................197

8.1.1 Spark Streaming 的不足之处... 198

8.1.2 Structured Streaming 的设计

理念 ............................................. 198

8.1.3 Structured Streaming 的处理

模型 ............................................. 199

8.1.4 Structured Streaming 和 Spark

SQL、Spark Streaming 的

关系 .............................................200

8.1.5 Structured Streaming 与其他

流处理技术的对比......................201

8.2 Structured Streaming 程序的编写

与测试运行 ................................201

8.2.1 编写程序......................................202

8.2.2 测试运行......................................203

8.3 输入源 ......................................205

8.3.1 File 源..........................................205

8.3.2 Kafka 源......................................210

8.3.3 Socket 源..................................... 213

8.3.4 Rate 源 ........................................ 213

8.4 输出操作 ...................................216

8.4.1 启动流计算.................................. 216

8.4.2 输出模式...................................... 216

8.4.3 输出接收器.................................. 217

8.5 容错处理 ...................................219

8.5.1 通过检查点恢复故障.................. 219

8.5.2 故障恢复中的限制...................... 219

4

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

8.6 迟到数据处理.............................220

8.6.1 事件时间......................................220

8.6.2 迟到数据......................................221

8.6.3 水印..............................................221

8.6.4 多水印规则..................................223

8.6.5 处理迟到数据的例子 ..................223

8.7 查询的管理和监控 ......................227

8.7.1 管理和监控的方法 ......................227

8.7.2 一个监控的实例 ..........................227

8.8 本章小结 ...................................229

8.9 习题..........................................230

实验 7 Structured Streaming 编程

初级实践 ...............................230

第 9 章 Spark MLlib .........232

9.1 基于大数据的机器学习................232

9.2 机器学习库 MLlib 概述................233

9.3 基本的数据类型..........................234

9.3.1 本地向量......................................234

9.3.2 标注点..........................................234

9.3.3 本地矩阵......................................235

9.3.4 数据源..........................................236

9.4 基本的统计分析工具 ...................238

9.4.1 相关性..........................................238

9.4.2 假设检验......................................239

9.4.3 汇总统计......................................240

9.5 机器学习流水线..........................240

9.5.1 流水线的概念..............................240

9.5.2 流水线的工作过程...................... 241

9.6 特征提取、转换和选择及局部敏感

哈希..........................................242

9.6.1 特征提取...................................... 242

9.6.2 特征转换...................................... 245

9.6.3 特征选择......................................250

9.6.4 局部敏感哈希.............................. 251

9.7 分类算法 ...................................251

9.7.1 逻辑斯谛回归分类算法.............. 252

9.7.2 决策树分类算法.......................... 256

9.8 聚类算法 ...................................259

9.8.1 K-Means 聚类算法.................... 259

9.8.2 GMM 聚类算法........................... 261

9.9 频繁模式挖掘算法 ......................264

9.9.1 FP-Growth 算法........................ 264

9.9.2 PrefixSpan 算法......................... 267

9.10 协同过滤算法...........................269

9.10.1 协同过滤算法的原理................ 269

9.10.2 ALS 算法...................................270

9.11 模型选择 .................................274

9.11.1 模型选择工具............................ 274

9.11.2 用交叉验证选择模型................ 274

9.12 本章小结 .................................276

9.13 习题........................................277

实验 8 Spark 机器学习库 MLlib 编程

初级实践 ...............................277

第1章 大数据技术概述

大数据时代的来临，给各行各业带来了深刻的变革。大数据像能源、原材料

一样，已经成为提升国家和企业竞争力的关键要素，被称为“未来的新石油”。

正如电力技术的应用引发了生产模式的变革一样，基于互联网技术而发展起来的

大数据技术的应用，将会对人们的生产和生活产生颠覆性的影响。

本章首先介绍大数据的概念与关键技术，然后重点介绍有代表性的大数据技

术，包括 Hadoop、Spark、Flink、Beam 等，最后探讨本书编程语言的选择，

并介绍与本书配套的在线资源。

1.1 大数据的概念与关键技术

2013 年被称为“大数据元年”，从此大数据技术开始辐射到商业的各个

角落。随着大数据时代的到来，“大数据”已经成为互联网信息技术行业的

流行词。本节介绍大数据的概念与关键技术。

1.1.1 大数据的概念

关于“什么是大数据”这个问题，学术界和业界比

较认可关于大数据的“4V”说法。大数据的 4 个“V”，

或者说是大数据的 4 个特点，包含 4 个方面：数据量大

（ Volume）、数据类型繁多（ Variety）、处理速度快

（Velocity）和价值密度低（Value）。

（1）数据量大。根据互联网数据中心（Internet Data Center，IDC）做出

的估测，人类社会产生的数据量一直都在以每年 50%的速度增长，这被称为

“大数据摩尔定律”。这意味着，人类在最近两年产生的数据量相当于之前产

生的全部数据量之和。

（2）数据类型繁多。大数据的数据类型丰富，包括结构化数据和非结构

化数据。其中，前者占 10%左右，主要是指存储在关系数据库中的数据；后

者占 90%左右，种类繁多，主要包括邮件、音频、视频、位置信息、链接信

息、手机呼叫信息、网络日志等。

（3）处理速度快。大数据时代的很多应用，需要基于快速生成的数据给

出实时分析结果，用于指导生产和生活实践。因此，数据处理和分析的速度

通常要达到秒级，这一点和传统的数据挖掘技术有着本质的不同，后者通常

01

大数据的概念

2

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

不要求给出实时分析结果。

（4）价值密度低。大数据价值密度远远低于传统关系数据库中的那些数据，在大数据时代，很

多有价值的信息都是分散在海量数据中的。

1.1.2 大数据关键技术

大数据的基本处理流程，主要包括数据采集、存储管理、处理分析、结果呈

现等环节。因此，从数据分析全流程的角度来看，大数据技术主要包括数据采集

与预处理、数据存储和管理、数据处理与分析、数据可视化、数据安全和隐私保

护等层面的内容，具体如表 1-1 所示。

表 1-1 大数据技术的不同层面及其功能

技术层面 功能

数据采集与预处理

利用抽取、转换、加载（Extract Transformation Load，ETL）工具将分布的、异构数据源中的数据，如

关系数据、平面数据等，抽取到临时中间层后进行清洗、转换、集成，最后加载到数据仓库或数据集

市中，成为联机分析处理、数据挖掘的基础；也可以利用日志采集工具（如 Flume、Kafka 等）把实时

采集的数据作为流计算系统的输入，进行实时处理分析

数据存储和管理 利用分布式文件系统、数据仓库、关系数据库、NoSQL 数据库、云数据库等，实现对结构化、半结构

化和非结构化海量数据的存储和管理

数据处理与分析 利用分布式并行编程模型和计算框架，结合机器学习和数据挖掘算法，实现对海量数据的处理和分析

数据可视化 对分析结果进行可视化呈现，帮助人们更好地理解数据、分析数据

数据安全和隐私保护 在从大数据中挖掘潜在的巨大商业价值和学术价值的同时，构建数据安全体系和隐私数据保护体系，

有效保护数据安全和个人隐私

此外，大数据技术及其代表性软件种类繁多，不同的技术都有其适用和不适用的场景。总体而

言，不同的企业应用场景，对应不同的大数据计算模式，根据不同的大数据计算模式，可以选择相

应的大数据计算产品，具体如表 1-2 所示。

表 1-2 大数据计算模式及其代表产品

大数据计算模式 解决问题 代表产品

批处理计算 针对大规模数据的批量处理 MapReduce、Spark 等

流计算 针对流数据的实时计算 Flink、Storm、S4、Flume、Streams、Puma、DStream、Super Mario、

银河流数据处理平台等

图计算 针对大规模图结构数据的处理 Pregel、GraphX、Giraph、PowerGraph、Hama、GoldenOrb 等

查询分析计算 针对大规模数据的存储管理和查询分析 Dremel、Hive、Cassandra、Impala 等

批处理计算主要用于解决针对大规模数据的批量处理，这也是我们日常数据分析工作中非常常

见的一类数据处理需求。比如，爬虫程序把大量网页数据抓取过来存储到数据库中以后，我们可以

使用 MapReduce 对这些网页数据进行批量处理，生成索引，以加快搜索引擎的查询速度。有代表性

的批处理计算框架包括 MapReduce、Spark 等。

流计算主要用来实时处理来自不同数据源的、连续到达的流数据，经过实时分析处理，给出有价

值的分析结果。比如，用户在访问淘宝网等电子商务网站时，在网页中每次单击的相关信息（比如选

取了什么商品）都会像水流一样实时传送到大数据分析平台，平台采用流计算技术对这些数据进行实

时处理分析，构建用户“画像”，为其推荐可能感兴趣的其他相关商品。有代表性的流计算框架包括 Flink、

Storm、S4 等。其中 Storm 是一个免费、开源的分布式实时计算系统，Storm 对于实时计算的意义类似

于 Hadoop 对于批处理的意义，Storm 可以简单、高效、可靠地处理流数据，并支持多种编程语言。Storm

可以方便地与数据库系统进行整合，从而开发出强大的实时计算系统。Storm 可用于许多领域中，如实

时分析、在线机器学习、持续计算、远程过程调用（Remote Procedure Call，RPC）等。由于 Storm 具

大数据关键技术

第 1 章 大数据技术概述

3

有可扩展、高容错、能可靠地处理消息等特点，目前已经被广泛应用于流计算应用中。

在大数据时代，许多大数据是以大规模图或网络的形式呈现的，如社交网络、传染病传播途径、交

通事故对路网的影响等。此外，许多非图结构的大数据，也常常会被转换为图结构数据后再进行处理分

析。图计算软件是专门针对图结构数据开发的，在处理大规模图结构数据时可以表现出很好的性能。谷

歌公司的 Pregel 是一种基于整体同步并行计算（Bulk Synchronous Parallel，BSP）模型实现的图计算框

架。为了解决大型图的分布式计算问题，Pregel 搭建了一套可扩展的、有容错机制的平台，该平台提供

了一套非常灵活的应用程序编程接口（Applicaton Program Interface，API），可以描述各种各样的图计算。

Pregel 作为分布式图计算的计算框架，主要用于图遍历、最短路径计算、PageRank 计算等。

查询分析计算也是一种在企业中常见的大数据计算模式，主要面向大规模数据的存储管理和查

询分析，用户一般只需要执行查询语句，如结构化查询语言（Structured Query Language，SQL）语

句，就可以快速得到相关的查询结果。典型的查询分析计算产品包括 Dremel、Hive、Cassandra、Impala

等。其中，Dremel 是一种可扩展的、交互式的实时查询系统，用于只读嵌套数据的分析，通过结合

多级树状执行过程和列式数据结构，它能做到几秒内完成对万亿张表的聚合查询。Dremel 系统可以

扩展到成千上万的 CPU 上，满足谷歌上万用户操作 PB 级别的数据的需求，并且可以在 2～3s 完成

对 PB 级别数据的查询。Hive 是一个构建于 Hadoop 顶层的数据仓库工具，允许用户通过输入 SQL

语句进行查询。Hive 在某种程度上可以看作用户编程接口，其本身并不存储和处理数据，而是依赖

Hadoop 分布式文件系统（Hadoop Distributed File System，HDFS）来存储数据，依赖 MapReduce 来

处理数据。Hive 作为现有的比较流行的数据仓库分析工具之一，得到了广泛的应用，但是由于 Hive

采用 MapReduce 来完成批量数据处理，因此，它的实时性不好，查询延迟较高。Impala 作为新一代

开源大数据分析引擎，支持实时计算，它提供了与 Hive 类似的功能，通过 SQL 语句能查询存储在

Hadoop 的 HDFS 和 HBase 上的 PB 级别的海量数据，并在处理速度上比 Hive 快 3～30 倍。

1.2 代表性大数据技术

大数据技术的发展速度很快，不断有新的技术涌现，这里着重介绍几种目前在市场上具有代表

性的大数据技术，包括 Hadoop、Spark、Flink、Beam 等。

1.2.1 Hadoop

Hadoop 是 Apache 软件基金会旗下的一个开源分布式计算平台，为用户提供

了系统底层细节透明的分布式计算架构。Hadoop 是基于 Java 语言开发的，具有很

好的跨平台特性，并且可以部署在计算机集群中。Hadoop 的核心是 HDFS 和

MapReduce。借助 Hadoop，程序员可以轻松地编写分布式并行程序，将其运行在

计算机集群上，完成海量数据的存储与计算。经过多年的发展，Hadoop 生态系统不断完善和成熟，

目前已经包含多个子项目，如图 1-1 所示。除了核心的 HDFS 和 MapReduce，Hadoop 生态系统还包括

YARN、Zookeeper、HBase、Hive、Pig、Mahout、Sqoop、Flume、Ambari 等组件。

这里简要介绍部分组件的功能，要了解 Hadoop 的更多细节内容，读者可以访问高校大数据课程

公共服务平台，学习《大数据技术原理与应用》在线视频的内容。

1．HDFS

HDFS 是针对谷歌文件系统（Google File System，GFS）的开源实现，它是 Hadoop 两大核心组

成部分之一，提供了在服务器集群中进行大规模分布式文件存储的功能。HDFS 具有很好的容错能

力，并且兼容一般的硬件设备，因此，用户可以以较低的成本利用现有机器实现大流量和大数据量

的读写。

Hadoop

4

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

图 1-1 Hadoop 生态系统

HDFS 采用主从（Master-Slave）结构模型，一个 HDFS 集群包括一个名称节点（NameNode）和

若干个数据节点（DataNode），如图 1-2 所示。名称节点作为中心服务器，负责管理文件系统的命名

空间及客户端（Client）对文件的访问。集群中的数据节点一般是一个节点运行一个数据节点进程，

负责处理文件系统的客户端的读/写数据请求，在名称节点的统一调度下进行数据块的创建、删除和

复制等操作。

图 1-2 HDFS 的体系结构

用户在使用 HDFS 时，仍然可以像在普通文件系统中那样，使用文件名去存储和访问文件。实

际上，在系统内部，一个文件会被切分成若干个数据块，这些数据块被分布存储到若干个数据节点

上。当客户端需要访问一个文件时，首先把文件名发送给名称节点，名称节点根据文件名找到对应

的数据块（一个文件可能包括多个数据块），再根据每个数据块信息找到实际存储各个数据块的数据

节点的位置，并把数据节点位置发送给客户端，最后，客户端直接访问这些数据节点获取数据。在

整个访问过程中，名称节点并不参与数据的传输。这种设计方式，使一个文件的数据能够在不同的

数据节点上实现并发访问，可大大提高数据的访问速度。

2．MapReduce

MapReduce 是一种分布式并行编程模型，用于大规模（大于 1TB）数据集的并行运算，它将复

第 1 章 大数据技术概述

5

杂的、运行于大规模集群上的并行计算过程高度抽象为两个函数：Map 和 Reduce。MapReduce 可极

大方便分布式编程工作，编程人员在不会分布式并行编程的情况下，也可以很容易地将自己的程序

运行在分布式系统上，完成海量数据的计算。

在 MapReduce 中，如图 1-3 所示，一个存储在

分布式文件系统中的大规模数据集，会被切分成许多

独立的小数据块（分片），这些小数据块可以被多个

Map 任务并行处理。MapReduce 框架会为每个 Map

任务输入一个数据子集，Map 任务生成的结果会继

续作为 Reduce 任务的输入，由 Reduce 任务输出最后

结果，并写入分布式文件系统。

MapReduce 设计的一个理念就是“计算向数据

靠拢”，而不是“数据向计算靠拢”，因为移动数据需要大量的网络传输开销，尤其是在大规模数据

环境下，这种开销尤为惊人，所以移动计算要比移动数据更加经济。本着这个理念，在一个集群中，

只要有可能，MapReduce 就会将 Map 程序就近地在 HDFS 数据所在的节点上运行，即将计算节点和

存储节点放在一起运行，从而减少节点间的数据移动开销。

3．YARN

YARN 是负责集群资源调度和管理的组件。YARN 的目标就是实现“一个集群多个框架”，即在

一个集群上部署一个统一的资源调度和管理框架 YARN。在 YARN 之上可以部署其他各种计算框架，

如图 1-4 所示，比如 MapReduce、Tez、Storm、Giraph、Spark、OpenMPI 等。YARN 为这些计算框

架提供统一的资源（包括 CPU、内存等资源）调度和管理服务，并且能够根据各种计算框架的负载

需求，调整各自占用的资源，实现集群资源共享和资源弹性收缩。通过这种方式，可以实现一个集

群上的不同应用的负载混搭，有效提高集群的利用率。同时，不同计算框架可以共享底层存储，在

一个集群上集成多个数据集，使用多个计算框架来访问这些数据集，从而避免数据集跨集群移动。

最后，这种部署方式还可以大大降低企业运维成本。目前，可以运行在 YARN 之上的计算框架包括

离线批处理框架 MapReduce、内存计算框架 Spark、流计算框架 Storm 和有向无环图（Directed Acyclic

Graph，DAG）计算框架 Tez 等。和 YARN 一样提供类似功能的其他资源调度和管理框架还包括

Mesos、Torca、Corona、Borg 等。

图 1-4 在 YARN 上部署各种计算框架

4．HBase

HBase 是针对谷歌 BigTable 的开源实现，是一个高可靠、高性能、面向列、可伸缩的分布式数

据库，主要用来存储非结构化和半结构化的松散数据。HBase 支持超大规模数据存储，它可以通过水

图 1-3 MapReduce 的工作流程

6

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

平扩展的方式，利用计算机集群处理由超过 10 亿行元素和数百万列元素组成的数据表。

图 1-5 描述了 Hadoop 生态系统中 HBase 与其他部分的关系。HBase 利用 MapReduce 来处理 HBase

中的海量数据，实现高性能计算；利用 Zookeeper 作为协同服务，实现稳定服务和失败恢复；使用

HDFS 作为高可靠的底层存储，利用集群提供海量数据存储能力，当然，HBase 也可以在单机模式下

使用，直接使用本地文件系统而不用 HDFS 作为底层数据存储方式，不过，为了提高数据可靠性和

系统的健壮性，发挥 HBase 处理大量数据等功能，一般使用 HDFS 作为 HBase 的底层数据存储方式。

此外，为了方便在 HBase 上进行数据处理，Sqoop 为 HBase 提供了高效、便捷的 RDBMS 数据导入

功能，Pig 和 Hive 为 HBase 提供了高层语言支持。

图 1-5 Hadoop 生态系统中 HBase 与其他部分的关系

5．Hive

Hive 是一个基于 Hadoop 的数据仓库工具，可用于对存储在 Hadoop 文件中的数据集进行数据整

理、特殊查询和分析处理。Hive 的学习门槛比较低，因为它提供了类似于 SQL 的查询语言——HiveQL。

当采用 MapReduce 作为底层执行引擎时，我们可以通过 HiveQL 语句快速实现简单的 MapReduce 统

计，Hive 自身可以自动将 HiveQL 语句快速转换成 MapReduce 任务进行运行，而不必开发专门的

MapReduce 应用程序，因而十分适合数据仓库中数据的统计分析。

6．Flume

Flume 是 Cloudera 公司开发的一个高可用、高可靠、分布式的海量日志采集、聚合和传输系统。

Flume 支持在日志系统中定制各类数据发送方和接收方，用于收集数据；同时，Flume 提供对数据进

行简单处理并将其传输给各种数据接收方的功能。

7．Sqoop

Sqoop 是 SQL-to-Hadoop 的缩写，主要用来在 Hadoop 和关系数据库之间交换数据，可以改进数

据的互操作性。通过 Sqoop，用户可以方便地将数据从 MySQL、Oracle、PostgreSQL 等关系数据库

中导入 Hadoop（比如导入 HDFS、HBase 或 Hive 中），或者将数据从 Hadoop 中导出到关系数据库，

使传统关系数据库和 Hadoop 之间的数据迁移变得非常方便。

1.2.2 Spark

1．Spark 简介

Spark 诞生于美国加利福尼亚大学伯克利分校的 AMP（Algorithms，Machines

and People）实验室，是一个可应用于大规模数据处理的快速、通用引擎，如今

是 Apache 软件基金会下的顶级开源项目之一。Spark 最初的设计目标是使数据

分析更快——不仅运行速度快，还要能使开发者快速、容易地编写程序。为了使程序运行更快，Spark

提供了内存计算和基于 DAG 的任务调度执行机制，减少了迭代计算时的 I/O 开销；而为了使开发

Spark

第 1 章 大数据技术概述

7

者编写程序更为容易，Spark 使用简练、优雅的 Scala 语言编写，基于 Scala 提供了交互式的编程体

验。同时，Spark 支持 Scala、Java、Python、R 等多种编程语言。

Spark 的设计遵循“一个软件栈满足不同应用场景”的理念，逐渐形成了一套完整的生态系统，

既可以提供内存计算框架，也可以支持 SQL 即席查询（Spark SQL）、流式计算（Spark Streaming 和

Structured Streaming）、机器学习（MLlib）和图计算（GraphX）等。Spark 可以部署在资源管理器 YARN

之上，提供一站式的大数据解决方案。因此，Spark 的生态系统同时支持批处理、交互式查询和流数

据处理等。

2．Spark 与 Hadoop 的对比

Hadoop 虽然已成为大数据技术的事实标准，但其本身还存在诸多缺陷。主要缺陷之一是 MapReduce

计算框架延迟过高，无法满足实时、快速计算的需求，因而只适用于离线批处理的应用场景。总体

而言，Hadoop 中的 MapReduce 计算框架主要存在以下缺点。

（1）表达能力有限。计算都必须转化成 Map 和 Reduce 两个操作，但这并不适合所有的情况，难

以描述复杂的数据处理过程。

（2）磁盘 I/O 开销大。每次执行时都需要从磁盘中读取数据，并且在计算完成后需要将中间结果

写入磁盘中，I/O 开销较大。

（3）延迟高。一次计算可能需要分解成一系列按顺序执行的 Map 和 Reduce 任务，任务之间的衔

接由于涉及 I/O 开销，会产生较高延迟。而且，在前一个任务执行完成之前，后面的任务无法开始，

因此，其难以胜任复杂、多阶段的计算任务。

（4）难以适用于多种应用场景。虽然 MapReduce 能够处理大规模的通用批处理作业，但结合机

器学习、流处理或者交互式 SQL 查询等其他应用场景的话，难免“力不从心”。为了应对这些新场景，

工程师开发了一些定制化的系统，如 Hive、Storm、Impala、Giraph、Drill 和 Mahout 等，但是，这些

系统都有自己的 API 和集群配置选项，因而进一步增加了 Hadoop 集群的运维复杂度，也使 Hadoop

开发的学习曲线更加陡峭。

Spark 在借鉴 MapReduce 优点的同时，很好地解决了 MapReduce 所面临的问题。相比于

MapReduce，Spark 主要具有如下优点。

（1）Spark 的计算框架类似于 MapReduce，但不局限于 Map 和 Reduce 操作，还提供了多种数据

集操作类型，编程模型比 MapReduce 更灵活。

（2）Spark 提供了内存计算，中间结果直接放到内存中，带来了更高的迭代运算效率。

（3）Spark 基于 DAG 的任务调度执行机制，要优于 MapReduce 的迭代执行机制。

（4）Spark 提供了多种组件，可以一站式支持批处理、流处理、查询分析、图计算、机器学习等

不同应用场景。

如图 1-6 所示，对比 Hadoop MapReduce 与 Spark 的执行流程，可以看到，Spark 最大的特点就

是将计算数据、中间结果都存储在内存中，大大减少了 I/O 开销，因而，Spark 更适用于迭代运算比

较多的数据挖掘与机器学习运算。

使用 Hadoop MapReduce 进行迭代计算非常耗资源，因为每次迭代都需要通过磁盘写入、读取中

间结果，I/O 开销大。而 Spark 将数据载入内存后，之后的迭代计算都可以直接使用内存中的中间结

果做运算，避免了从磁盘中频繁读取数据。如图 1-7 所示，Hadoop 与 Spark 在执行逻辑斯谛回归

（Logistic Regression）时所需的时间相差巨大。

在实际开发时，使用 Hadoop 需要编写不少相对底层的代码，不够高效。相对而言，Spark 提供

了多种高层次、简洁的 API。通常情况下，对于实现相同功能的应用程序，Spark 的代码量要比 Hadoop

少很多。更重要的是，Spark 提供了实时交互式编程反馈，可以方便用户验证、调整算法。

8

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

图 1-6 Hadoop MapReduce 与 Spark 的执行流程对比

图 1-7 Hadoop 与 Spark 执行逻辑斯谛回归的时间对比

近年来，大数据机器学习和数据挖掘的并行化算法研究，成为大数据领域一个较为重要的研究

热点。在 Spark 崛起之前，学术界和业界普遍关注的是 Hadoop 平台上的并行化算法设计。但是，

MapReduce 的网络和磁盘读写开销大，难以高效地实现需要大量迭代计算的机器学习并行化算法。

因此，近年来国内外的研究重点开始转到如何在 Spark 平台上实现各种机器学习和数据挖掘的并行化

算法设计。为了方便一般应用领域的数据分析人员使用熟悉的 R 语言在 Spark 平台上完成数据分析，

第 1 章 大数据技术概述

9

Spark 提供了一个名为“Spark R”的编程接口，使一般应用领域的数据分析人员可以在 R 语言的环

境里方便地使用 Spark 的并行化编程接口和强大的计算功能。

3．Spark 与 Hadoop 的统一部署

Spark 正以其结构一体化、功能多元化的优势，逐渐成为当今大数据领域热门的大数据计算平台

之一。目前，越来越多的企业放弃 MapReduce，转而使用 Spark 开发企业应用。但是，需要指出的是，

Spark 作为计算框架，只是取代了 Hadoop 生态系统中的计算框架 MapReduce，而 Hadoop 中的其他

组件依然在企业大数据系统中发挥重要作用。比如，企业依然需要依赖 HDFS 和分布式数据库 HBase

来实现不同类型数据的存储和管理，并借助 YARN 实现集群资源的调度和管理。因此，在许多企业

实际应用中，Hadoop 和 Spark 的统一部署是一种比较合理的选择。由于 MapReduce、Tez、Storm 和 Spark

等都可以运行在资源管理框架 YARN 之上，因此可以在 YARN 之上统一部署各种计算框架，如图 1-8

所示。这些不同的计算框架统一运行在 YARN 中，具有以下几个优点：

（1）计算资源按需伸缩；

（2）不用混搭应用负载，集群利用率高；

（3）共享底层存储，避免数据跨集群迁移。

图 1-8 在 YARN 之上统一部署各种计算框架

1.2.3 Flink

1．Flink 简介

Flink 是 Apache 软件基金会的顶级项目之一，是一个针对流数据和批量数据的

分布式计算框架，设计思想主要来源于 Hadoop、MPP 数据库、流计算系统等。Flink

主要是由 Java 代码实现的（部分模块使用 Scala 代码实现），目前主要依靠开源社

区的贡献而发展。Flink 所要处理的主要场景是流数据，批量数据只是流数据的一个特例而已，也就是

说，Flink 会把所有任务当成流来处理。Flink 可以支持本地的快速迭代任务以及一些环形的迭代任务。

Flink 以层级式系统形式组建其软件栈，其架构如图 1-9 所示，不同层的栈建立在其下层基础上。

具体而言，Flink 的典型特性如下。

（1）提供了面向流处理的 DataStream API 和面向批处理的 DataSet API，其中 DataSet API 支持

Java、Scala 和 Python，DataStream API 支持 Java 和 Scala。

（2）提供了多种候选部署方案，比如本地（Local）模式、集群（Cluster）模式和云（Cloud）模

式等，对集群模式而言，可以采用独立（Standalone）模式或者 YARN。

（3）提供了一些类库，包括 Table（处理逻辑表查询）、FlinkML（机器学习）、Gelly（图像处理）

和 CEP（复杂事件处理）。

（4）提供了较好的 Hadoop 兼容性，不仅可以支持 YARN，还可以支持 HDFS、HBase 等数据源。

Flink

10

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

图 1-9 Flink 架构

2．Flink 和 Spark 的比较

目前开源大数据计算引擎有很多选择，典型的流计算框架包括 Storm、Samza、Flink、Kafka

Streams、Spark Streaming、Structured Streaming 等，典型的批处理框架包括 Spark、Hive、Pig、Flink

等。而同时支持流处理和批处理的计算引擎，只有两种选择：一种是 Spark，另一种是 Flink。因此，

这里有必要对二者做一下比较。

Spark 和 Flink 都是 Apache 软件基金会旗下的顶级项目，二者具有很多共同点，具体如下。

（1）都是基于内存的计算框架，因此，都可以获得较好的实时计算性能。

（2）都有统一的批处理和流处理 APl，都支持类似 SQL 的编程接口。

（3）都支持很多相同的转换操作，编程都使用类似于 Scala Collection APl 的函数式编程模式。

（4）都有完善的错误恢复机制。

（5）都支持“精确一次”（Exactly Once）的语义一致性。

表 1-3、表 1-4 和表 1-5 分别给出了 Flink 和 Spark 在 API、支持语言、部署模式方面的比较，从

中可以看出二者具有很大的相似性。

表 1-3 Flink 和 Spark 在 API 方面的比较

API Spark Flink

底层 API RDD Process Function

核心 API DataFrame/DataSet DataStream/DataSet

SQL Spark SQL Table API 和 SQL

机器学习 MLlib FlinkML

图计算 GraphX Gelly

其他 — FlinkCEP

表 1-4 Flink 和 Spark 在支持语言方面的比较

支持语言 Spark Flink

Java √ √

Scala √ √

Python √ √

R √ 第三方

SQL √ √

第 1 章 大数据技术概述

11

表 1-5 Flink 和 Spark 在部署模式方面的比较

部署模式 Spark Flink

Local(Single JVM) √ √

Standalone Cluster √ √

YARN √ √

Mesos √ √

Kubernetes √ √

同时，Flink 和 Spark 还存在一些明显的区别，具体如下。

（1）Spark 的技术理念是基于批计算来模拟流计算。而 Flink 则完全相反，它采用的是基于流计

算来模拟批处理。从技术发展方向看，用批处理来模拟流计算有一定的技术局限性，并且这个局限

性可能很难突破。而 Flink 基于流计算来模拟批处理，在技术上有更好的扩展性。

（2）Flink 和 Spark 都支持流计算，二者的区别在于，Flink 会一条一条地处理数据，而 Spark 会

基于弹性分布式数据集（Resilient Distributed Dataset，RDD）小批量处理数据，所以，Spark 在流式

处理方面，不可避免地会增加一些延时，实时性没有 Flink 好。Flink 的流计算性能和 Storm 差不多，

可以支持毫秒级响应，而 Spark 则只能支持秒级响应。

（3）当全部运行在 Hadoop YARN 之上时，Flink 的性能要略好于 Spark，因为 Flink 支持增量迭

代，具有对迭代进行自动优化的功能。

总体而言，Flink 和 Spark 都是非常优秀的基于内存的分布式计算框架，二者各有优势。Spark 在

生态上更加完善，在机器学习的集成和易用性上更有优势；而 Flink 在流计算上更有优势，并且在核

心架构和模型上更加通透、灵活。相信在未来很长一段时间内，二者将互相促进，共同成长。

1.2.4 Beam

在大数据处理领域，开发者经常要用到很多不同的技术、框架、API、开发语

言和 SDK 等。根据不同的企业业务系统开发需求，开发者很可能会用 MapReduce

进行批处理，用 Spark SQL 进行交互式查询，用 Flink 实现实时流处理，还有可能

用到基于云端的机器学习框架。大量的开源大数据产品（如 MapReduce、Spark、Flink、

Storm、Apex 等），在为大数据开发者提供了丰富的工具的同时，也增加了开发者选择合适工具的难度，

尤其对新入行的开发者来说更是如此。新的分布式处理框架可能带来更高的性能、更强大的功能和更

低的延迟，但是，用户切换到新的分布式处理框架的代价也非常大——需要学习一个新的大数据处理

框架，并重写所有的业务逻辑。解决这个问题的思路包括两个部分：首先，需要一个编程范式，能够

统一、规范分布式数据处理的需求，例如，统一批处理和流处理的需求；其次，生成的分布式数据处

理任务，应该能够在各个分布式执行引擎（如 Spark、Flink 等）上执行，用户可以自由切换分布式数

据处理任务的执行引擎与执行环境。Apache Beam，就是为了解决这个问题而出现的。

Beam 是由谷歌贡献的 Apache 顶级项目，它的目标是为开发者提供一个易于使用且很强大

的数据并行处理模型，能够支持流处理和批处理，并兼容多个运行平台。Beam 是一个开源的统

一的编程模型，开发者可以使用 Beam SDK 来创建数据处理管道，然后，所写的程序可以在任

何支持的执行引擎上运行，比如运行在 Apex、Spark、Flink、Cloud Dataflow 上。Beam SDK 定

义了开发分布式数据处理任务业务逻辑的 API，即提供一个统一的编程接口给上层应用的开发

者，开发者不需要了解底层的具体的大数据平台的开发接口是什么，直接通过 Beam SDK 的接

口，就可以开发数据处理的加工流程，不管输入是用于批处理的有限数据集，还是用于流处理

的无限数据集。对于有限或无限的输入数据，Beam SDK 都使用相同的类来表现，并且使用相同

的转换操作进行处理。

Beam

12

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

如图 1-10 所示，终端用户用 Beam 来实现自己所需的流计算功能，使用的终端语言可能是 Python、

Java 等，Beam 为每种语言提供了一个对应的 SDK，用户可以使用相应的 SDK 创建数据处理管道，

用户写出的程序可以被运行在各个 Runner 上，每个 Runner 都实现了从 Beam 管道到平台功能的映射。

目前主流的大数据处理框架 Flink、Spark、Apex 以及谷歌的 Cloud DataFlow 等，都有了支持 Beam

的 Runner。通过这种方式，Beam 使用一套高层抽象的 API 屏蔽多种计算引擎的区别，开发者只需要

编写一套代码就可以将其运行在不同的执行引擎之上（如 Apex、Spark、Flink、Cloud Dataflow、

Gearpump 和 Samza 等）。

图 1-10 Beam 使用一套高层抽象的 API 屏蔽多种计算引擎的区别

1.3 编程语言的选择

大数据处理框架 Hadoop、Spark、Flink 等，都支持多种类型的编程语言。比

如，Hadoop 可以支持 C、C++、Java、Python 等，Spark 可以支持 Java、Scala、

Python 和 R 等。因此，在使用 Spark 等大数据处理框架进行应用程序开发之前，

需要选择一门合适的编程语言。

1.3.1 不同编程语言简介

R 是专门为统计和数据分析开发的语言，具有数据建模、统计分析和可视化等功能，简单易上手。

Python 是目前国内外很多大学里流行的入门语言，学习门槛低，简单易用，开发人员可以使用 Python

来构建桌面应用程序和 Web 应用程序，此外，Python 在学术界备受欢迎，常被用于科学计算、数据

分析和生物信息等领域。R 和 Python 都是比较流行的数据分析语言，相对而言，数学和统计领域的

工作人员更多使用 R 语言，而计算机领域的工作人员更多使用 Python。

Java 是目前热门的编程语言之一，虽然 Java 没有和 R、Python 一样好的可视化功能，也不是统计

建模的最佳工具，但是，如果需要建立一个庞大的应用系统，那么 Java 通常会是较为理想的选择。Java

编程语言的选择

第 1 章 大数据技术概述

13

由于具有简单、面向对象、分布式、安全、体系结构中立、可移植、高性能、多线程及动态性等诸多

优良特性，因此被大量应用于企业的大型系统开发中，企业对于 Java 人才的需求一直比较旺盛。

Scala 是一门类似 Java 的多范式语言，它整合了面向对象编程和函数式编程的诸多特性。本书采

用 Scala 语言编写 Spark 应用程序，主要基于以下几个原因。

（1）Scala 具备强大的并发性，支持函数式编程，可以更好地支持分布式系统。在大数据时代，

为了提高应用程序的并发性，函数式编程日益受到关注。Scala 提供的函数式编程风格，已经吸引了

大量的开发者。

（2）Scala 兼容 Java，可以与 Java 互操作。Scala 代码文件会被编译成 Java 的.class 文件（即在 JVM

上运行的字节码文件）。开发者可以从 Scala 中调用所有的 Java 类库，也同样可以从 Java 应用程序中

调用 Scala 的代码。此外，Java 是热门的编程语言之一，在企业中有大量的 Java 开发人员，国内大

多数高校也都开设了 Java 课程。因此，学习 Scala 可以很好地实现与 Java 的衔接，让之前在 Java 方

面的学习和工作成果能够得到延续。

（3）Scala 代码简洁优雅。Scala 语言非常精炼，实现同样功能的程序，Scala 所需的代码量通常

比 Java 少一半或者更多。短小精悍的代码常常意味着更易维护，拥有其他语言编程经验的编程人员

很容易读懂 Scala 代码。

（4）Scala 支持高效的交互式编程。Scala 提供了交互式解释器（Read-Eval-Print-Loop，REPL），因

此，在 spark-shell 中可进行交互式编程（表达式计算完成就会输出结果，而不必等到整个程序运行完

毕，因此，编程人员可即时查看中间结果，并对程序进行修改），这样可以在很大程度上提高开发效率。

（5）Scala 是 Spark 的开发语言。由于 Spark 计算框架本身就是采用 Scala 语言开发的，因此用

Scala 语言编写 Spark 应用程序可以获得非常好的执行性能。

1.3.2 Spark 开发语言对比

Spark 原生语言接口只支持 Scala 和 Java，这对非计算机相关专业的人员来说

不够友好，不利于 Spark 的推广与使用。为了方便使用，Spark 提供了两种让数据

分析师非常容易上手的语言接口：Python 和 R。这两种语言接口的出现，极大地

扩充了 Spark 的使用人群。Python 的简单易学和高效率开发等特性，使 Python 逐

渐成为 Spark 主流开发语言之一。为了保证 Spark 核心实现的独立性，Spark 仅在外围包装了 PySpark

和 SparkR 两个中间件来实现对 Python 和 R 语言的支持。

虽然 Spark 支持使用 Java、Scala、Python 和 R 语言来开发应用程序，但是不同编程语言在开发

效率、执行效率等方面还是有些不同的，表 1-6 对不同的 Spark 开发语言进行了对比。

表 1-6 Spark 支持的开发语言对比

编程语言 类型 开发效率 执行效率 成熟度 支持类型

Scala 编译型 中 高 高 原生支持

Java 编译型 低 高 高 原生支持

Python 解释型 高 中 中 PySpark

R 解释型 高 中 低 SparkR

总体而言，Java 语法冗长，开发效率较低，并不是非常适合用作数据分析语言；Python 在执行

效率上稍打折扣（效率要比 Scala 和 Java 低）；R 语言对计算机领域的人员而言较少使用，而且 SparkR

的成熟度有待提高。所以，Scala 是 Spark 开发的首选语言，用其开发的 Spark 应用程序的性能是很

高的。需要说明的是，虽然本书采用 Scala 语言开发 Spark 应用程序，但是读者通过学习本书熟悉了

Spark 的运行原理和编程方法后，就能很容易地通过阅读相关工具书和网络资料，快速学习如何使用

Java 和 Python 等语言开发 Spark 应用程序。

Spark 开发语言对比

14

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

1.4 在线资源

本书提供了全部配套资源，包括源代码、讲义 PPT、授课视频、技术资料、

实验习题、大数据软件、数据集等，如表 1-7 所示，读者可访问高校大数据课程

公共服务平台进行在线浏览和下载。

表 1-7 配套资源内容说明

项目 内容说明

命令行语句和代码 在网页上给出了本书中出现的命令行语句、代码、配置文件内容等，读者可以直接从网页中复制代码去执

行，不需要自己手动输入代码

实验指南 详细介绍了本书中涉及的各种软件的安装方法和编程实践细节

下载专区 包含本书内各章所涉及的软件、代码文件、讲义 PPT、习题和答案、数据集等

在线视频 包含与本书配套的在线授课视频

先修课程 包含与本书相关的先修课程及其配套资源，为读者更好地学习本书提供了大数据基础知识的补充；需要强

调的是，只是建议学习，不是必须学习，即使不学习先修课程，读者也可以顺利完成本书的学习

综合案例 提供了免费共享的 Spark 课程综合案例

高校大数据课程

公共服务平台

提供大数据教学资源一站式免费在线服务，包括课程教材、讲义 PPT、课程习题、实验指南、学习指南、

备课指南、授课视频和技术资料等，本书中涉及的大数据技术，在平台上都有配套学习资源

需要说明的是，本书用于教授进阶级大数据课程，在学习本书之前，建议（不是必须）读者具

备一定的大数据基础知识，了解大数据基本概念以及 Hadoop、HDFS、MapReduce、HBase、Hive 等

大数据技术。高校大数据课程公共服务平台中提供了与本书配套的两本入门级图书，包括《大数据

技术原理与应用》和《大数据基础编程、实验和案例教程》，可以作为本书相关的先修课程教材。其

中，《大数据技术原理与应用》以“构建知识体系、阐明基本原理、开展初级实践、了解相关应用”

为原则，旨在为读者搭建起通向大数据知识空间的“桥梁”，为读者在大数据领域深耕细作奠定基础、

指明方向，该书系统论述了大数据的基本概念、大数据处理架构 Hadoop、分布式文件系统 HDFS、

分布式数据库 HBase、NoSQL 数据库、云数据库、分布式并行编程模型 MapReduce、大数据处理架

构 Spark、流计算、图计算、数据可视化以及大数据在互联网、生物医学和物流等各个领域的应用；

《大数据基础编程、实验和案例教程》是《大数据技术原理与应用》的配套实验指导书，侧重于介绍

大数据软件的安装、使用和基础编程方法，并提供了丰富的实验和案例。

1.5 本章小结

大数据时代已经全面开启，大数据技术正在不断发展、进步。大数据技术包含了庞杂的知识体

系，Spark 作为基于内存的分布式计算框架，只是其中的一种代表性技术。在具体学习 Spark 之前，

建立对大数据技术体系的整体性认识、了解 Spark 和其他大数据技术之间的关系是非常有必要的。因

此，本章从总体上介绍了大数据关键技术以及具有代表性的大数据计算框架。

与本书配套的资源，是帮助读者更加快速、高效学习本书的重要保障，因此，本章详细列出了

与本书配套的各种在线资源，读者可以免费使用。

1.6 习题

1．请阐述大数据处理的基本流程。

2．请阐述大数据的计算模式及其代表产品。

在线资源

第 1 章 大数据技术概述

15

3．请列举 Hadoop 生态系统的各个组件及其功能。

4．HDFS 的名称节点和数据节点的功能分别是什么？

5．试阐述 MapReduce 的基本设计思想。

6．YARN 的主要功能是什么？使用 YARN 可以带来哪些好处？

7．试阐述 Hadoop 生态系统中 HBase 与其他部分的关系。

8．数据仓库 Hive 的主要功能是什么？

9．Hadoop 主要有哪些缺点？相比之下，Spark 具有哪些优点？

10．如何实现 Spark 与 Hadoop 的统一部署？

11．相对于 Spark，Flink 在实现机制上有什么不同？

12．Beam 的设计目的是什么，具有哪些优点？

实验 1 Linux 操作系统的安装和常用命令

一、实验目的

（1）掌握 Linux 虚拟机的安装方法。Spark 和 Hadoop 等大数据软件在 Linux 操作系统（以下简

称“Linux 系统”）上运行时可以发挥非常好的性能，因此，本书中，Spark 都是在 Linux 系统中进行

相关操作的，同时，第 2 章将要介绍的 Scala 语言也会在 Linux 系统中安装和操作。鉴于目前很多读

者正在使用 Windows 操作系统（以下简称“Windows 系统”），为了顺利完成本书的后续实验，这里

有必要通过本实验，让读者掌握在 Windows 系统上搭建 Linux 虚拟机的方法。当然，安装 Linux 虚

拟机只是安装 Linux 系统的其中一种方式，实际上，读者也可以不用虚拟机，而是采用双系统的方式

安装 Linux 系统。本书推荐使用虚拟机方式。

（2）熟悉 Linux 系统的基本使用方法。本书全部在 Linux 环境下进行实验，因此，需要读者提前

熟悉 Linux 系统的基本用法，尤其是一些常用命令的使用方法。

二、实验平台

操作系统：Windows 系统和 Ubuntu（推荐）。

虚拟机软件：推荐使用开源虚拟机软件 VirtualBox。VirtualBox 是一款功能强大的免费虚拟机软

件，它不仅具有丰富的特色，性能也很优异，且简单易用。可虚拟的操作系统包括 Windows、macOS

X、Linux、OpenBSD、Solaris、OS/2 甚至 Android 等操作系统。读者可以在 Windows 系统上安装

VirtualBox 软件，然后在 VirtualBox 上安装并且运行 Linux 系统。本实验默认的 Linux 发行版为 Ubuntu

18.04.5。

三、实验内容和要求

1．安装 Linux 虚拟机

请登录 Windows 系统，下载 VirtualBox 软件和 Ubuntu 18.04.5 镜像文件。

或者直接到高校大数据课程公共服务平台本书页面“下载专区”的“软件”中下载 Ubuntu 安装

文件 ubuntukylin-18.04.5-desktop-amd64.iso。

首先，在 Windows 系统上安装虚拟机软件 VirtualBox，然后在虚拟机软件 VirtualBox 上安装 Ubuntu

18.04.5 操作系统，具体请参考高校大数据课程公共服务平台本书页面“实验指南”中的“在 Windows

中使用 VirtualBox 安装 Ubuntu”。

16

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

2．使用 Linux 系统的常用命令

启动 Linux 虚拟机，进入 Linux 系统，通过查阅 Linux 书籍和网络资料，或者参考本书的“实验

指南”的“Linux 系统常用命令”，完成如下操作：

（1）切换到目录“/usr/bin”；

（2）查看目录“/usr/local”下的所有文件；

（3）进入“/usr”目录，创建一个名为“test”的目录，并查看有多少目录存在；

（4）在“/usr”目录下新建目录“test1”，再复制这个目录内容到“/tmp”；

（5）将上面的“/tmp/test1”目录重命名为“test2”；

（6）在“/tmp/test2”目录下新建 word.txt 文件并输入一些字符串，保存退出；

（7）查看 word.txt 文件内容；

（8）将 word.txt 文件所有者改为 root 账号，并查看属性；

（9）找出“/tmp”目录下文件名为“test2”的文件；

（10）在“/”目录下新建目录“test”，然后在“/”目录下将其打包成 test.tar.gz；

（11）将 test.tar.gz 解压缩到“/tmp”目录。

3．在 Windows 系统和 Linux 系统之间互传文件

本书大量实验都是在 Linux 虚拟机上完成的，因此，读者需要掌握如何把 Windows 系统中的文

件上传到 Linux 系统，以及如何把 Linux 系统中的文件下载到 Windows 系统。

首先，到高校大数据课程公共服务平台本书页面“下载专区”中的“软件”目录中下载 FTP 软

件 FileZilla 的安装文件 FileZilla_3.17.0.0_win64_setup.exe，把 FileZilla 安装到 Windows 系统中；然后，

请参考本书“实验指南”栏目的“在 Windows 系统中利用 FTP 软件向 Ubuntu 系统上传文件”，完成

以下操作：

（1）在 Windows 系统中新建一个文本文件 test.txt，并通过 FTP 软件 FileZilla 将 test.txt 上传到

Linux 系统中的“/home/hadoop/下载”目录下，利用 Linux 命令把该文件名修改为“test1”；

（2）通过 FTP 软件 FileZilla，将 Linux 系统中的“/home/hadoop/下载”目录下的 test1.txt 文件下

载到 Windows 系统的某个目录下。

四、实验报告

Spark 编程基础实验报告

题目： 姓名： 日期：

实验环境：

实验内容与完成情况：

出现的问题：

解决方案（列出已解决的问题的解决办法，以及没有解决的问题）：

第2章 Scala语言基础

Spark 作为一个通用的分布式并行计算框架，支持采用 Scala、Java、

Python 和 R 语言开发应用程序。由于 Spark 本身就是使用 Scala 语言开发的，

Scala 与 Spark 可以实现无缝结合，因此 Scala 顺理成章地成了开发 Spark 应

用的首选语言。

本章对 Scala 语言进行简要介绍。需要强调的是，本章的目的是为读者学

习 Spark 编程提供基础的 Scala 语言预备知识，而不是系统阐述 Scala 语言的

完整特性。因此，本章只介绍 Scala 的常用核心语言特性，而忽略许多高级特

性（包括 Scala 的并发模型、高级参数类型及元编程等）。

本章首先简要介绍 Scala 语言以及 Scala 的安装和使用方法等；然后阐述

Scala 编程的基础知识，包括基本数据类型和变量、I/O、控制结构、数据结构

等；最后介绍面向对象编程和函数式编程的基础知识。

2.1 Scala 语言概述

本节首先对计算模型的理论研究历史和编程范式的发展进行简要的概

述，然后介绍 Scala 语言的发展背景及基本特性，最后详细介绍 Scala 的安装

方法和各种运行方式。

2.1.1 计算机的缘起

从 20 世纪 30 年代开始，一些数学家开始研究如何设

计一台拥有无穷计算能力的超级机器，来帮人类自动完成

一些计算问题。

数学家阿朗佐·丘奇（Alonzo Church）提出了“λ 演

算”的概念，这是一套用于研究函数定义、函数应用和递归的形式系统。λ 演

算被视为最小的通用程序设计语言，它包括一条变换规则（变量替换）和一个

函数定义方式。λ 演算的通用性体现在，任何一个可计算函数都能用这种形

式来表达和求值。λ 演算强调的是变换规则的运用，而非实现它的具体机器。

我们可以认为它是一种更接近软件而非硬件的系统。它是一个数理逻辑形式

系统，使用变量代入和置换来研究基于函数定义和应用的计算。

英国数学家阿兰·图灵（Alan Turing）采用了完全不同的设计思路，提出

了一种全新的抽象计算模型。该模型现在被称为“图灵机”，它将人们使用纸

02

计算机的缘起

18

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

笔进行数学运算的过程抽象为一个虚拟的机器。图 2-1 是图灵机示意。图灵机有一条无限长的纸带，纸

带分成了一个一个的小方格，每个方格有不同的颜色。有一个机器头在纸带上移来移去。机器头有一组

内部状态，还有一些固定的程序。在每个时刻，机器头都要从当前纸带上读入一个方格信息，然后结合

自己的内部状态查找程序表，根据程序输出信息到纸带方格上，并转换自己的内部状态，然后进行移动。

这种理论计算模型是现代计算机的鼻祖。现有理论已经证明，λ 演算和图灵机的计算能力是等价的。

图 2-1 图灵机示意

如果说图灵奠定的是计算机的理论基础，那么冯·诺依曼（John Von Neumann）则将图灵的理论

物化成为实际的物理实体，这也让他成为计算机体系结构的奠基者。1945 年 6 月，冯·诺依曼提出

了在数字计算机内部的存储器中存放程序的概念，这是所有现代计算机的范式，被称为“冯·诺依

曼结构”，按这一结构制造的计算机被称为“存储程序计算机”，也称“冯·诺依曼计算机”。冯·诺

依曼计算机主要由运算器、控制器、存储器和 I/O 设备组成，它的特点是，程序以二进制代码的形式

存放在存储器中，所有的指令都由操作码和地址码组成，指令在存储器中按顺序存放，以运算器和

控制器作为计算机结构的中心等。从第一台冯·诺依曼计算机诞生到今天已经过去很多年了，计算

机的技术与性能也都发生了巨大的变化，但是，计算机主流体系结构依然是冯·诺依曼结构。

2.1.2 编程范式

编程范式是指计算机编程的基本风格或典范模式。常见的编程范式主要包括

命令式编程和函数式编程。面向对象编程就属于命令式编程，如 C++、Java 等的

编程。

命令式语言是植根于冯·诺依曼结构的，一个命令式程序就是一个冯·诺依曼计算机的指令序

列，给机器提供一条又一条的命令序列让其原封不动地执行。函数式编程，又称泛函编程，它将计

算机的计算视为数学上的函数计算，并且避免使用程序状态及易变对象。函数式语言重要的基础是 λ

演算，而且 λ 演算的函数可以接收函数作为输入和输出，因此，λ 演算对函数式编程特别是 Lisp 语

言有巨大的影响。典型的函数式语言包括 Haskell、Erlang 和 Lisp 等。

从理论上说，函数式语言并不是通过冯·诺依曼计算机运行的，而是通过 λ 演算来运行的，但

是，由于现代计算机都采用冯·诺依曼结构，所以，函数式程序还是会被编译成冯·诺依曼计算机

编程范式

19

第 2 章 Scala 语言基础

的指令来执行。

我们很自然地会想到的问题是，既然已经有了命令式编程，为什么还需要函数式编程呢？为什

么在 C++、Java 等的命令式编程流行了很多年以后，近些年函数式编程会迅速“升温”呢？这些问

题的答案需要从 CPU 制造技术的变化说起。从 20 世纪 70 年代至 21 世纪初，CPU 的制造工艺不断

提升，晶体管数量不断增加，运行频率不断提高，如图 2-2 所示。在几十年里，CPU 的运行频率已经

从 10MHz 提高到 3.6GHz。但是，CPU 的制造工艺不可能无限提升，单个 CPU 内集成的晶体管数量

不可能无限增加，因此，从 2005 年以来，计算机计算能力的增长已经不依赖 CPU 主频的增长，而

是依赖 CPU 核数的增多，CPU 开始从单核发展到双核，再到四核，甚至更多核。

对命令式编程而言，由于涉及多线程之间的状态共享，就需要引入锁机制实现并发控制。而函数式

编程则不会在多个线程之间共享状态，不会造成资源争用，也就不需要用锁机制来保护可变状态，自然

也就不会出现死锁，这样可以更好地实现并行处理。函数式编程能够更好地利用多个处理器（核）提供

的并行处理能力，所以函数式编程受到更多的关注。此外，由于函数式语言是面向数学的抽象，更接近

人的语言，而不是机器语言，因此，函数式语言的代码更加简洁，也更容易被理解。

图 2-2 1970—2010 年 CPU 的工艺参数及性能变化

2.1.3 Scala 简介

编程语言的流行主要归功于其技术上的优势以及其对某种时代需求的适应

性。例如，Java 的流行主要归功于其跨平台特性和互联网应用的广泛需求。从 2010

年开始，随着物联网及大数据等技术的发展，编程语言面对的是具有高并发性、

异构性及快速开发等特点的应用场景，这些场景使函数式编程可以大展拳脚。但

Scala 简介

20

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

传统的面向对象编程的“统治地位”并没有被剥夺，因此，能够将二者结合起来的混合式编程范式

是适应当前需求的最好解决方案。Scala 语言正是在这一背景下开始流行起来的。

Scala 是由瑞士洛桑联邦理工学院的马丁·奥德斯基（Martin Odersky）教授于 2001 年基于 Funnel

的工作开始设计的。Scala 是一门类 Java 的多范式语言，它整合了面向对象编程和函数式编程的最佳

特性，具体如下。

（1）Scala 运行于 Java 虚拟机（JVM）之上，并且兼容现有的 Java 程序，可以与 Java 类进行互

操作，包括调用 Java 方法、创建 Java 对象、继承 Java 类和实现 Java 接口等。

（2）Scala 是一门纯粹的面向对象的语言。在 Scala 语言中，每个值都是对象，每个操作都是方

法调用。对象的数据类型及行为由类和特质描述。类抽象机制的扩展有两种途径，一种途径是子类

继承，另一种途径是灵活的混入（Mixin）机制，这两种途径能避免多重继承的诸多问题。

（3）Scala 也是一门函数式语言。在 Scala 语言中，每个函数都是一个对象，并且和其他类型的

值（如整数、字符串等）处于同一地位。Scala 提供了轻量级的语法用以定义匿名函数，同时支持高

阶函数，允许嵌套多层函数，并支持柯里化（Currying）。

Scala 语言的名称来自 Scalable，意为“可伸展的语言”。Scala 的“可伸展性”归功于其集成了

面向对象和函数式语言的优点。Scala 的一种常用方式是通过解释器输入单行表达式来即时运行并观

察结果，因此，对某些应用来说，Scala 就像一种脚本语言，它的语法简单，在变量类型自动推断机

制下，无须时刻关注变量的类型，但保留了强制静态类型的诸多优势。同时，用 Scala 语言编写的程

序也可以编译、打包、发布，其生成的代码就是 Java 字节码。已经有许多大型的业务系统或框架采

用 Scala 作为首选的开发语言，包括 Spark 和领英等。

2.1.4 Scala 的安装

Scala 于 2004 年 1 月公开发布 1.0 版本，目前仍处于发展阶段，每隔几个月就

有新的版本发布。Spark 从 3.0 版本开始采用 Scala 2.12 编译，因为本书使用的

Spark 版本是 3.2.0，其对应的 Scala 版本是 2.12.15，所以，本书中的 Scala 选用 2021

年 9 月更新的 2.12.15 版本。

Scala 运行在 JVM 之上，因此只要安装相应的 JVM，所有的操作系统都可以运行 Scala 程序，包

括 Windows、Linux、UNIX、macOS 等。本书后续的 Spark 操作都是在 Linux 系统下进行的，因此，

这里以 Linux 系统（选用 Ubuntu 发行版）为例，简要介绍 Scala 的安装及环境配置。

首先，需要安装 Linux 系统，具体安装方法请参见高校大数据课程公共服务平台本书页面“实验

指南”栏目中的“Linux 系统的安装”。此外，在安装 Scala 之前，请确保本机 Linux 系统中已经安装

了 Java 8 或以上版本的 JDK（Scala 2.12 需要 Java 8 支持），具体安装方法请参见“实验指南”栏目

中的“Linux 系统中 Java 的安装”。

根据官网的安装指南，可以选择安装集成开发环境 IntelliJ 或者命令行构建工具 sbt，也可以直接

下载相应的二进制包进行安装。前两种方式可以根据安装页面的介绍进行，下面简要介绍直接下载

二进制包的安装步骤。以 2.12.15 版本为例，通过官网下载 Linux 系统对应的安装包 scala-2.12.15.tgz，

也可以直接从高校大数据课程公共服务平台本书页面“下载专区”中的“软件”目录中下载

scala-2.12.15.tgz；在 Linux 系统中下载和解压缩文件的具体方法，可以参考“实验指南”栏目中的

“Linux 系统中下载安装文件和解压缩方法”。下载后，将 scala-2.12.15.tgz 解压缩到 Linux 系统的本地

目录下，如“/usr/local”，这时会在该目录下生成一个新的目录 scala-2.12.15，编译器及各种库文件即

位于该目录下，为以后启动 Scala 方便，可以把 scala-2.12.15 重命名为“scala”，并建议将其下的 bin

目录添加到 PATH 环境变量。在终端（即 Linux Shell 环境）中运行“scala -version”命令，查看是否

正确安装，如果已经正确安装，则会显示 Scala 编译器的版本信息。

Scala 的安装

21

第 2 章 Scala 语言基础

2.1.5 编写及运行 HelloWorld 程序

学习 Scala 的较简单的方法是使用 Scala REPL。与 Python 及 MATLAB 等语言

的解释器一样，Scala REPL是一个运行Scala表达式和程序的交互式Shell，在REPL

里输入一个表达式，它将计算这个表达式并输出结果值。在 Linux 系统中打开一

个终端（可以使用组合键 Ctrl+Alt+T），执行如下命令启动 Scala REPL。

$ cd /usr/local/scala #这是 Scala 的安装目录

$ ./bin/scala

正常启动后，终端将出现“scala>”提示符，此时即

可输入 Scala 表达式，默认情况下一行代表一个表达式或

语句，按 Enter 键后 Scala REPL 即运行该语句或表达式

并显示结果。如果一条语句需要占用多行，只需要在一

行以一个不能合法作为语句结尾的字符（如句点、未封

闭的括号、引号中间的字符）结束，则 Scala REPL 会自

动在下一行以“|”开头，提示用户继续输入。图 2-3 所

示是几个输入示例，其中，关于函数 show( )的定义语句占用了多行。

直接在解释器里编写程序，一次只能运行一行。如果想运行多行，可以用脚本的方式编写，只

需要将多行程序保存为文本文件，然后在 Linux Shell 中用“scala 文件名”这种形式的命令来运行即

可，或者在 Scala REPL 中用“:load 文件名”的形式装载、执行。下面请在 Linux 系统中打开一个终

端，在“/usr/local/scala/”目录下创建一个 mycode 目录，在 mycode 目录下，使用文本编辑器（如 vim

编辑器）创建一个代码文件 Test.scala（vim 编辑器的使用方法可以参考高校大数据课程公共服务平

台本书页面“实验指南”栏目中的“Linux 系统中 vim 编辑器的安装和使用方法”）。Test.scala 的内容

如下：

//代码文件为/usr/local/scala/mycode/Test.scala

println(\"This is the first line\")

println(\"This is the second line\")

println(\"This is the third line\")

然后，可以在 Scala REPL 中执行如下命令运行该代码文件。

scala> :load /usr/local/scala/mycode/Test.scala

Loading /usr/local/scala/mycode/Test.scala…

This is the first line

This is the second line

This is the third line

在 Scala REPL 中执行“:quit”可以退出解释器环境。除了使用 Scala REPL 运行 Scala 程序，还

可以通过编译打包的方式运行 Scala 程序。

首先，在 Linux 系统中创建一个代码文件 HelloWorld.scala，内容如下。

//代码文件为/usr/local/scala/mycode/HelloWorld.scala

object HelloWorld {

def main(args: Array[String]) {

println(\"Hello, world!\");

}

}

使用如下命令对代码文件 HelloWorld.scala 进行编译。

$ cd /usr/local/scala/mycode

$ scalac HelloWorld.scala

编译成功后，将会生成 HelloWorld$.class 和 HelloWorld.class 两个文件，其中后一个文件是可以在

图 2-3 在 Scala REPL 中一条语句占用多行的效果

编写及运行

HelloWorld 程序

22

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

JVM 上运行的字节码文件。然后可以使用如下命令运行该程序。

$ scala -classpath . HelloWorld

正常情况下，程序将在新的一行输出“Hello, world!”字样。如果出现“No such file or class on

classpath: HelloWorld”错误，则是因为当前目录不在类路径下。

可以看出，这与编译和运行 Java 的 HelloWorld 程序非常类似，事实上，Scala 的编译和执行模型

与 Java 的是等效的，上面编译后的字节码文件也可以用以下命令运行。

$ java -classpath .:/usr/local/scala/lib/scala-library.jar HelloWorld

其中，scala-library.jar 为 Scala 类库。

关于上面的 Scala 源文件 HelloWorld.scala，这里对照 Java 做几点简要说明。

（1）HelloWorld 是用关键字 object 定义的单例对象（Singleton Object），它提供了一个 main( )方

法用作应用程序的入口点。这里要注意 Scala 的 main( )方法与 Java 的 main( )方法之间的区别，Java

中的是静态方法（public static void main(String[] args)）；而 Scala 没有提供静态方法，改为使用单例

对象方法，每一个独立应用程序都必须有一个定义在单例对象中的 main( )方法。

（2）尽管对象的名字 HelloWorld 与源文件名称 HelloWorld.scala 一致，但是对 Scala 而言，这

并不是必须的。实际上，可以任意命名源文件，比如这里可以把源文件命名为 Test.scala，源文件

里面的单例对象名称继续使用 HelloWorld。可以看出，在这个方面，Scala 和 Java 是不同的，按照

Java 的命名要求，这里的文件名称就只能为 HelloWorld.scala，也就是文件名称必须和文件中定义

的类（Class）名称保持一致。虽然 Scala 没有要求文件名称和单例对象名称一致，但是，这里仍然

推荐像在 Java 里那样按照所包含的类名来命名文件，这样程序员可以通过查看文件名称的方式方

便地找到类。

（3）Scala 是大小写敏感的语言，采用分号“;”分隔语句，但与 Java 不同的是，一行 Scala 程序

的最后一条语句末尾的分号是可以省略的。在 HelloWorld.scala 中，第 3 行末尾的分号是可以省略的。

2.2 Scala 基础知识

本节介绍 Scala 基础知识，包括基本数据类型和变量、I/O、控制结构和数据结构等。

2.2.1 基本数据类型和变量

1．基本数据类型

表 2-1 列出了 Scala 的 9 种基本数据类型及其取值范围。其中，类型 Byte、

Short、Int、Long 和 Char 统称为整数类型，Float 和 Double 统称为浮点数类型。

可以看出，Scala 与 Java 有相同的基本数据类型，只是类型修饰符的首字母大小写不同，Scala 中

所有基本数据类型的首字母都采用大写，而 Java 中除了字符串类型用首字母大写的 String，其他 8

种基本数据类型都采用首字母小写的修饰符。

Scala 是一门纯粹的面向对象的语言，每个值都是对象，也就是说 Scala 没有 Java 中的原生类型，

表 2-1 中列出的数据类型都有相应的类与之对应。在 Scala 中，除了 String 类型在 java.lang 包中被

声明之外，其余类型都是包 scala 的成员。例如，Int 的全名是 scala.Int。由于包 scala 和 java.lang 的

所有成员都会被每个 Scala 源文件自动引用，因此可以省略包名，而只用 Int、Boolean 等简化名。

表 2-1 Scala 的基本数据类型

数据类型 取值范围

Byte 8 位有符号的补码整数，[-27

，27

-1]

Short 16 位有符号的补码整数，[-215，215-1]

基本数据类型和变量

23

第 2 章 Scala 语言基础

续表

数据类型 取值范围

Int 32 位有符号的补码整数，[-231，231-1]

Long 64 位有符号的补码整数，[-263，263-1]

Char 16 位无符号的 Unicode 字符，[0，216-1]

String 字符串

Float 32 位 IEEE 754 单精度浮点数

Double 64 位 IEEE 754 双精度浮点数

Boolean true 或 false

除了以上 9 种基本数据类型，Scala 还提供了一个 Unit 类型，类似 Java 中的 void 类型，表示“什

么都不是”，主要作为不返回任何结果的函数的返回结果类型。

2．字面量

字面量是直接在源代码里书写常量值的一种方式。不同类型的字面量书写语法如下。

（1）整数字面量

整数字面量有两种格式：十进制和十六进制。十进制数开始于非零数字，十六进制数开始于 0x

或 0X。需要注意的是，不论用什么进制的字面量进行初始化，Scala 的 Shell 始终输出十进制整数值。

整数字面量默认被编译器解释为 Int 类型数据，如果需要表示 Long 类型数据，需要在数字后面添加

大写字母 L 或者小写字母 l。

（2）浮点数字面量

浮点数字面量是由十进制数字、小数点、可选的 E 或 e 及指数部分组成的。如果以 F 或 f 结尾，

浮点数字面量会被编译器解释为 Float 类型数据，否则被解释为 Double 类型数据。

（3）布尔值字面量

布尔值字面量只有 true 和 false 两种。

（4）字符及字符串字面量

字符字面量是在半角单引号之间的任何 Unicode 字符，还可以用反斜杠“\\”表示转义字符。字

符串字面量用半角双引号引起一系列字符来表示，如果需要表示多行文本，则用 3 个双引号引起。

举例如下。

scala> val c='A'

c: Char = A

scala> var c1='\E'

c1: Char = E

scala> c1='\\''

c1: Char = '

scala> val s = \"hello world\"

s: String = hello world

scala> val ss = \"\"\"the first line

| the second line

| the third line\"\"\"

ss: String =

the first line

the second line

the third line\"

（5）Unit 字面量

Unit 字面量只有一个值，用空的圆括号表示，即“( )”。

3．操作符

Scala 为它的基本数据类型提供了丰富的操作符，如下。

24

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

（1）算术运算符：加“+”、减“-”、乘“*”、除“/”、求余“%”。

（2）关系运算符：大于“>”、小于“<”、等于“=”、不等于“!=”、大于等于“>=”、小于等于

“<=”。

（3）逻辑运算符：逻辑与“&&”、逻辑或“||”、逻辑非“!”。

（4）位运算符：按位与“&”、按位或“|”、按位异或“^”、按位取反“～”、左移“<<”、右移

“>>”、无符号右移“>>>”。

（5）赋值运算符：“=”及其与其他运算符结合的扩展赋值运算符，如“+=”“%=”。

需要强调的是，尽管这些操作符在使用上与 Java 中的基本一致，但是 Scala 的操作符实际上是

方法，也就是说，在 Scala 中，每个操作都是方法调用，操作符不过是对象方法调用的一种简写形式。

例如，5 + 3 和 5.+(3)是等价的，因为 Scala 作为一门纯粹的面向对象语言，它的每个值都是一个对象，

即这里的数值 5 也是一个 Int 类型的对象，由于 Int 类有一个名为“+”的方法，它接收一个 Int 类型

参数并返回一个 Int 类型的结果，因此，5.+(3)就表示在 5 这个对象上调用名称为“+”的方法，把 3

作为参数传递给该方法，完成加法计算。实际上，Int 类还包含了许多带不同参数类型的重载加法方

法。例如，有一个名为“+”的、参数和返回结果类型都为 Double 的方法。所以，执行 5+3.5 会返回

Double 类型的 8.5，相当于调用了 5.+(3.5)。另外，与 Java 不同的是，Scala 中各种赋值表达式的值都

是 Unit 类型的，因此，尽管 a=b=5 是合法的语句，但它并不表示将 a 和 b 的值都赋值为 5。实际上，

执行该语句时，首先执行赋值表达式 b=5，使 b 的值变为 5，b=5 这个赋值表达式的值是 Unit 类型的，

这样 a 就成为 Unit 类型值。

Scala 操作符的优先级和 Java 的基本相同，从高到低基本遵循以下顺序。

算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

唯一的例外是，逻辑非（!）有比算术运算符更高的优先级。在实际应用中，没有必要记住所有

操作符之间的优先级顺序，推荐的做法是，除了不言自明的优先级（如乘除法优先级比加减法高）

以外，尽量使用括号去厘清表达式中操作符的优先级。

对于基本数据类型，除了以上提到的各种操作符，Scala 还提供了许多常用运算的方法，只是这

些方法不是在基本类里面定义，而是被封装到与各个基本类对应的所谓“富包装类”中。表 2-1 中每

个基本数据类型都有一个对应的富包装类。例如，Int 有一个对应的 RichInt 类、String 有一个对应的

RichString 类，这些富包装类位于包 scala.runtime 中。当对一个基本数据类型的对象调用其富包装类

提供的方法时，Scala 会自动通过隐式转换，将该对象转换为对应的富包装类型数据，再调用相应的

方法。例如，执行语句 3 max 5 时，Scala 检测到基本数据类型 Int 没有提供 max( )方法，但是 Int 的

富包装类 RichInt 具有 max( )方法，这时，Scala 会自动将 3 这个对象转换为 RichInt 类型数据，然后

调用 RichInt 的 max( )方法，并将 5 作为参数传给该方法，最后返回的结果是 Int 类型的 5。

4．变量

尽管 Scala 有多种基本数据类型，但是从声明变量的角度看，Scala 只有两种类型的变量，分别

使用关键字 val 和 var 进行声明。对于用 val 声明的变量，在声明时就必须被初始化，而且初始化以

后就不能再被赋予新的值；对于用 var 声明的变量，是可变的，可以被多次赋值。声明一个变量的基

本语法格式如下。

val 变量名:数据类型 = 初始值

var 变量名:数据类型 = 初始值

与 Java 中“变量类型 变量名=值”的语法结构相比，Scala 变量声明的语法结构略显烦琐，但是，

Scala 提供了一种类型推断（Type Inference）机制，它会根据初始值自动推断变量的数据类型，这使

声明变量时可以省略具体的数据类型及其前面的冒号。例如，语句 var str= \"Hello world\"与 var str :

String = \"Hello world\"的作用是一样的，因为使用字符串文本初始化变量 str，Scala 可以自动推断出 str

25

第 2 章 Scala 语言基础

的类型是 String。同理，var i=1 和 var i:Int=1 也是等价的。但是，如果需要将 i 定义为浮点数类型，

则必须显式指定类型，如 var i:Double=1，或者用浮点数类型的值初始化，如 var i=1.0。

需要注意的是，在 Scala REPL 环境下，可以重复使用同一个变量名来定义变量，而且变量前的

关键字和变量类型都可以不一致，Scala REPL 会以最新的一个定义为准，示例如下。

scala> val a = \"Xiamen University\"

a: String = Xiamen University

scala> var a = 50

a: Int = 50

2.2.2 I/O

1．控制台 I/O 语句

为了从控制台读取数据，可以使用以 read 为前缀的方法，包括 readInt( )、

readDouble( )、readByte( )、readShort( )、readFloat( )、readLong( )、readChar( )、

readBoolean( )及 readLine( )，分别对应 9 种基本数据类型。其中，前 8 种方法没有参数，readLine( )

可以不提供参数，也可以带一个字符串参数作为输入提示。所有这些方法都属于对象 scala.io.StdIn，

使用前必须导入该对象，或者直接用全称进行调用。使用示例如下。

scala> import io.StdIn._

import io.StdIn._

scala> var i=readInt()

54

i: Int = 54

scala> var f=readFloat

1.618

f: Float = 1.618

scala> var b=readBoolean

true

b: Boolean = true

scala> var str=readLine(\"please input your name:\")

please input your name:Li Lei

str: String = Li Lei

需要注意的是，在 Scala REPL 中，从键盘读取数据时，看不到用户的输入，需要按 Enter 键以

后才能看到效果。

为了向控制台输出信息，常用的两个函数是 print( )和 println( )，可以直接输出字符串或者其他类

型数据，两个函数唯一的区别是，后者输出结束时会默认加一个换行符，而前者没有，示例如下。

scala> val i=345

i: Int = 345

scala> print(\"i=\");print(i) //两条语句位于同一行，不能省略中间的分号

i=345

scala> println(\"hello \");println(\"world\")

hello

world

此外，Scala 的 printf( )函数还可以使用 C 语言风格的格式化字符串，示例如下。

scala> val i = 34

i: Int = 34

scala> val f=56.5

f: Double = 56.5

scala> printf(\"I am %d years old and weight %.1f kg.\",i,f)

I am 34 years old and weight 56.5 kg.

上述提到的 3 个输出函数（print( )、println( )和 printf( )）都是在对象 Predef 中定义的，该对象在

I/O

26

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

默认情况下会自动被所有 Scala 程序引用，因此，我们可以直接使用 Predef 对象提供的 print( )、println( )

和 printf( )等函数，而无须使用 scala.Predef.println(\"Hello World\")这种形式。另外，Scala 提供了字符

串插值机制，以方便在字符串字面量中直接嵌入变量的值。为了构造一个插值字符串，只需要在字

符串字面量前加一个“s”字符或“f”字符，然后，在字符串中即可以用“$”插入变量的值，s 插值

字符串不支持格式化，f 插值字符串支持在“$变量”后接格式化参数，示例如下。

scala> val i=10

i: Int = 10

scala> val f=3.5452

f: Double = 3.5452

scala> val s=\"hello\"

s: String = hello

scala> println(s\"$s:i=$i,f=$f\") //s 插值字符串

hello:i=10,f=3.5452

scala> println(f\"$s:i=$i%-4d,f=$f%.1f\") //f 插值字符串，%-4d 表示按左对齐输出 4 位宽的整数

hello:i=10 ,f=3.5

2．读写文件

Scala 使用类 java.io.PrintWriter 实现文本文件的创建与写入。该类由 Java 库提供，这正好体现了

Scala 与 Java 的互操作性。PrintWriter 类提供了 print( )和 println( )两种写函数，其用法与向控制台输

出数据所采用的 print( )和 println( )完全一样。示例如下。

scala> import java.io.PrintWriter

scala> val outputFile = new PrintWriter(\"test.txt\")

scala> outputFile.println(\"Hello World\")

scala> outputFile.print(\"Spark is good\")

scala> outputFile.close()

上面的语句中，new PrintWriter(\"test.txt\")中使用了相对路径地址，这意味着文件 test.txt 会被保存到

启动 Scala REPL 时的当前目录下。例如，如果在“/usr/local/scala”目录下使用 scala 命令启动 Scala REPL，

则 test.txt 会被保存到“/usr/local/scala”目录下。如果要把文件保存到一个指定的目录下，就需要在 new

PrintWriter( )的圆括号中给出文件路径全称，如 new PrintWriter(\"/usr/local/scala/mycode/output.txt\")。

尽管 Java 的 PrintWriter 类也提供了 printf( )函数，但是由于 Scala 对部分 Java 类的整合度不够，

在 Scala 中，不能用 PrintWriter 类来实现数值类型数据的格式化写入。为了实现数值类型数据的格式

化写入，可以使用 String 类的 format( )方法，或者用 f 插值字符串，示例如下。

scala> import java.io.PrintWriter

scala> val outputFile = new PrintWriter(\"test.txt\")

scala> val i = 9

scala> outputFile.print(\"%3d --> %d\

\".format(i,i*i))

scala> outputFile.println(f\"$i%3d --> ${i*i}%d\") //与上句等效

scala> outputFile.close()

Scala 使用类 scala.io.Source 实现对文件的读取，常用的方法是 getLines( )方法，它会返回一个包

含所有行的迭代器（迭代器是一种数据结构，将在 2.2.4 小节中介绍）。下面是从一个文件读出所有

行并输出的实例代码。

scala> import scala.io.Source

scala> val inputFile = Source.fromFile(\"test.txt\")

scala> for (line <- inputFile.getLines()) println(line) // 输出内容已省略

scala> inputFile.close()

2.2.3 控制结构

同各种高级语言一样，Scala 也包括内建的选择结构和循环结构。其中，选择

结构包括 if 语句，循环结构包括 while 语句和 for 语句。另外，Scala 也有内建的 控制结构

27

第 2 章 Scala 语言基础

异常处理结构 try-catch。

1．if 语句

if 语句用来实现有两个分支的选择结构，基本语法格式如下。

if (表达式) {

语句块 1

}

else {

语句块 2

}

执行 if 语句时，会首先检查表达式是否为真，如果为真，就执行语句块 1，如果为假，就执行语

句块 2，示例如下。

scala> val x = 6

x: Int = 6

scala> if (x>0) {println(\"This is a positive number\")

| } else {

| println(\"This is not a positive number\")

| }

This is a positive number

Scala 与 Java 类似，if 语句中 else 子句是可选的，而且 if 子句和 else 子句中都支持多层嵌套 if

语句，示例如下。

scala> val x = 3

x: Int = 3

scala> if (x>0) {

| println(\"This is a positive number\")

| } else if (x==0) {

| println(\"This is a zero\")

| } else {

| println(\"This is a negative number\")

| }

This is a positive number

与 Java 不同的是，Scala 中的 if 语句会返回一个值，因此，可以将 if 语句赋值给一个变量，这与

Java 中的三元操作符“?:”类似，示例如下。

scala> val a = if (6>0) 1 else -1

a: Int = 1

2．while 语句

Scala 的 while 语句和 Java 的完全一样，包括以下两种基本结构，只要表达式为真，循环体就会

被重复执行，其中，do-while 的循环体至少会被执行一次。

while (表达式){

循环体

}

或者

do{

循环体

}while (表达式)

3．for 语句

与 Java 的 for 语句相比，Scala 的 for 语句在语法格式上有较大的不同，同时，for 语句也不是 while

语句的替代者。for 语句提供了遍历各种容器（容器的概念将在 2.2.4 小节中介绍）的强大功能，用法

也更灵活。for 语句最简单的用法就是对一个容器的所有元素进行枚举，基本语法格式如下。

28

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

for (变量 <- 表达式) {语句块}

其中，“变量 <- 表达式”被称为“生成器”（Generator），该处的变量不需要用关键字 var 或 val

进行声明，其类型为后面的表达式对应的容器中的元素类型，每枚举一次，变量就被容器中的一个

新元素所初始化，示例如下。

scala> for (i <- 1 to 3) println(i)

1

2

3

其中，1 to 3 为一个整数的 Range 型容器（将在 2.2.4 小节中介绍 Range），包含 1、2 和 3。i 依

次从 1 枚举到 3。for 语句可以对任何类型的容器类进行枚举，示例如下。

scala> for (i <- Array(3,5,6)) println(i)

3

5

6

其中，Array(3,5,6)创建了一个数组（将在 2.2.4 小节中进一步介绍），for 语句依次对数组的 3 个

元素进行了枚举。可以发现，通过这种方式遍历一个数组，比使用 Java 语言的表达方法更加简洁高

效，而且不需要考虑索引是从 0 还是 1 开始，也不会发生数组越界问题。

for 语句不仅可以对一个集合进行完全枚举，还可以通过添加过滤条件对某一个子集进行枚举，

这些过滤条件被称为“守卫式”（Guard），基本语法格式如下。

for (变量 <- 表达式 if 条件表达式) 语句块

此时，只有当变量取值满足 if 后面的条件表达式时，语句块才会被执行，示例如下。

scala> for (i <- 1 to 5 if i%2==0) println(i)

2

4

上面的语句在执行时，只输出 1 到 5 之间能被 2 整除的数。如果需要添加多个过滤条件，可以

增加多个 if 语句，并用分号隔开。从功能上讲，上述语句等同于以下语句。

for (i <- 1 to 5)

if (i%2==0) println(i)

可以通过添加多个生成器实现嵌套的 for 语句，其中，生成器之间用分号隔开，示例如下。

scala> for (i <- 1 to 5; j <- 1 to 3) println(i*j)

1

2

3

2

…

其中，外循环为 1～5，内循环为 1～3。与单个生成器类似，在多个生成器中，每个生成器都可

以通过 if 子句添加守卫式来进行条件过滤。

以上所有的 for 语句都只对枚举值进行某些操作后即结束，实际上，Scala 的 for 语句灵活之处体

现在，可以在每次执行的时候创造一个值，然后将包含所有产生值的容器对象作为 for 语句的结果返

回。为了做到这一点，只需要在循环体前加上 yield 关键字，即 for 语句如下。

for (变量 <- 表达式) yield {语句块}

其中，yield 后的语句块中最后一个表达式的值作为每次循环的返回值，示例如下。

scala> val r=for (i <- Array(1,2,3,4,5) if i%2==0) yield { println(i); i}

2

4

r: Array[Int] = Array(2,4)

执行结束后，r 为包含元素 2 和 4 的新数组。这种带有 yield 关键字的 for 语句，被称为“for 推

29

第 2 章 Scala 语言基础

导式”。也就是说，通过 for 语句遍历一个或多个集合，对集合中的元素进行推导，从而计算得到新

的集合，用于后续的其他处理。

4．异常处理结构

Scala 不支持 Java 中的检查型异常（Checked Exception），将所有异常都当作非检查型异常，因

此，在方法声明中不需要像 Java 中那样使用 throw 关键字。和 Java 一样，Scala 也使用 try-catch 结构

来捕获异常，示例如下。

import java.io.FileReader

import java.io.FileNotFoundException

import java.io.IOException

try {

val f = new FileReader(\"input.txt\") //文件操作

} catch {

case ex: FileNotFoundException =>… //文件不存在时的操作

case ex: IOException =>… //发生 I/O 异常时的操作

} finally {

file.close() //确保关闭文件

}

如果 try 子句正常执行，则没有异常抛出；反之，如果执行时发生异常，则抛出异常。该异常被

catch 子句捕获，捕获的异常与每个 case 子句中的异常类别进行比较（这里使用了模式匹配，将在 2.3.6

小节中介绍）。如果异常是 FileNotFoundException，第一个 case 子句将被执行；如果是 IOException，

第二个 case 子句将被执行；如果都不是，那么该异常将向上层代码抛出。此外，不管是否发生异常，

finally 子句都会被执行。finally 子句是可选的。与 Java 类似，Scala 也支持使用 throw 关键字手动抛

出异常。

5．对循环的控制

为了提前终止整个循环或者跳到下一个循环，Java 提供了 break 和 continue 两个关键字，但是，

Scala 没有提供这两个关键字，而是通过一个名称为 Breaks 的类来实现类似的功能，该类位于包

scala.util.control 下。Breaks 类有两个方法用于对循环结构进行控制，即 breakable 和 break，通常放在

一起配对使用，其基本使用方法如下。

breakable{

…

if(…) break

…

}

即将需要控制的语句块作为参数放在 breakable 内部。然后，其内部在某个条件满足时会调用

break 方法，程序将跳出 breakable 方法。通过这种通用的方式，就可以实现 Java 循环中的 break 和

continue 功能。下面通过一个例子来说明，在 Linux 系统中新建一个代码文件 TestBreak.scala，内容

如下。

//代码文件为/usr/local/scala/mycode/TestBreak.scala

import util.control.Breaks._ //导入 Breaks 类的所有方法

val array = Array(1,3,10,5,4)

breakable{

for(i<- array){

if(i>5) break //跳出 breakable，终止循环，相当于 Java 中的 break

println(i)

}

}

//上面的 for 语句将输出 1、3

30

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

for(i<- array){

breakable{

if(i>5) break //跳出 breakable，终止本次循环，相当于 Java 的 continue

println(i)

}

}

//上面的 for 语句将输出 1、3、5、4

可以在 Scala REPL 中使用“:load /usr/local/scala/mycode/TestBreak.scala”执行该代码文件并查看

程序执行效果。

2.2.4 数据结构

在 Scala 编程中经常需要用到各种数据结构，如数组、元组、容器、序列、集合、映射、迭代器等。

1．数组

数组（Array）是一种可变的、可索引的、元素具有相同类型的数据集合，它

是各种高级语言中常用的数据结构之一。Scala 提供了参数化类型的通用数组类

Array[T]，其中 T 可以是任意的 Scala 类型。Scala 数组与 Java 数组是一一对应的，

即 Scala 的 Array[Int]可看作 Java 的 Int[]，Scala 的 Array[Double]可看作 Java 的

Double[]，Scala 的 Array[String]可看作 Java 的 String[]。可以通过显式指定类型或

者通过隐式推断来实例化一个数组，示例如下。

scala> val intValueArr = new Array[Int](3)

scala> val myStrArr = Array(\"BigData\",\"Hadoop\",\"Spark\")

第一行通过 new 关键字并显式给出类型参数 Int 定义了一个长度为 3 的整数数组，数组的每个元

素默认初始化为 0。第二行省略了数组元素的类型，而通过具体的 3 个字符串来初始化，Scala 自动

推断出当前数组为字符串数组，因为 Scala 会选择初始化元素的最近公共类型作为 Array 的参数类型。

需要注意的是，第二行中没有像第一行那样使用 new 关键字来生成一个对象，这是因为其使用了 Scala

中的所谓伴生对象的 apply( )方法，具体将在 2.3.2 小节中介绍。

另外，不同于 Java 的方括号，Scala 使用圆括号来访问数组元素，索引也是从 0 开始的。例如，

对于上述定义的两个数组，可以通过 intValueArr(0)=5 改变数组元素的值，myStrArr(1)返回字符串

\"Hadoop\"。Scala 使用圆括号而不是方括号来访问数组元素，这里涉及 Scala 的伴生对象的 update( )

方法，具体将在 2.3.2 小节中介绍。

需要注意的是，尽管两个数组变量都用 val 关键字进行定义，但是，这只表明这两个变量不能指

向其他的对象，而对象本身是可以改变的，因此可以对数组内容进行改变。

既然 Array[T]类是一个通用的参数化类型，那么我们可以将 T 也设置为 Array 类型来定义多维数

组。Array 提供了函数 ofDim( )来定义二维数组和三维数组，用法如下。

val myMatrix = Array.ofDim[Int](3,4)

val myCube = Array.ofDim[String](3,2,4)

其中，第一行定义了一个 3 行 4 列的二维整数数组，在 Scala REPL 中可以看到其类型实际就是

Array[Array[Int]]，即它就是一个普通的数组对象，只不过该数组的元素也是数组。同理，第二行定

义了一个三维长度分别为 3、2、4 的三维字符串数组，其类型实际是 Array[Array[Array[String]]]。同样，

我们可以使用多级圆括号来访问多维数组的元素，如 myMatrix(0)(1)返回第 1 行第 2 列的元素。

2．元组

Scala 的元组是对多个不同类型对象的一种简单封装。Scala 提供了 TupleN 类（N 的范围为 1～

22），用于创建一个包含 N 个元素的元组。构造一个元组的语法很简单，只需把多个元素用逗号分开

数据结构（数组、

元组）

31

第 2 章 Scala 语言基础

并用圆括号包围起来就可以了，示例如下。

scala> val tuple = (\"BigData\",2015,45.0)

这里定义了包含 3 个元素的元组，3 个元素的类型分别为 String、Int 和 Double，因此实际上该元

组的类型为 Tuple3[String,Int,Double]。可以使用下画线“_”加上从 1 开始的索引来访问元组的元素。

例如，对于刚定义的元组 tuple，tuple._1 的值是字符串\"BigData\"，tuple._3 的值是浮点数 45.0。还可以

一次性提取出元组中的元素并赋值给变量，例如，以下代码展示了直接提取 tuple 的 3 个元素的值，并

分别赋值给 3 个变量（实际上这里涉及 Scala 的模式匹配机制，将在 2.3.6 小节中进一步介绍）。

scala> val (t1,t2,t3) = tuple

t1: String = BigData

t2: Int = 2015

t3: Double = 45.0

如果需要在方法里返回多个不同类型的对象，Scala 可以简单地返回一个元组，为了实现相同的

功能，Java 通常需要创建一个类去封装多个返回值。

3．容器

Scala 提供了一套丰富的容器（Collection）库，定义了列表、映射、集合等

常用数据结构。根据容器中元素的组织方式和操作方式，可以区分出有序和无序、

可变和不可变等不同的容器类别。Scala 用 3 个包来组织容器类，分别是

scala.collection、scala.collection.mutable 和 scala.collection.immutable。从名字即可看

出 scala.collection.immutable 包是指元素不可变的容器类；scala.collection.mutable

包指的是元素可变的容器；而 scala.collection 封装了一些可变容器和不可变容器的超类或特质（将在

2.3.5 小节中介绍，这里可以将其理解为 Java 中的接口），定义了可变容器和不可变容器的一些通用

操作。scala.collection 包中的容器通常具备对应的不可变实现和可变实现。

Scala 为容器的操作精心设计了很多细粒度的特质，但对用户来说，无须掌握每一个特质的使用

方法，因为 Scala 已经通过混入这些特质生成了各种高级的容器。图 2-4 所示为 scala.collection 包中

容器的宏观层级结构（省略了很多细粒度的特质）。所有容器类的根为 Traverable 特质，表示可遍历

的，它为所有的容器类定义了抽象的 foreach( )方法，该方法用于对容器元素进行遍历操作。混入

Traverable 特质的容器类必须给出 foreach( )方法的具体实现。Traverable 的下一级为 Iterable 特质，表

示元素可一个个地依次迭代，该特质定义了一个抽象的 iterator( )方法，混入该特质的容器类必须实

现 iterator( )方法，返回一个迭代器（Iterator）。另外，Iterable 特质还给出了其从 Traverable 继承的 foreach( )

方法的一个默认实现，即通过迭代器进行遍历。

图 2-4 scala.collection 包中容器的宏观层次结构

数据结构（容器、

序列）

32

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

Iterable 下的继承层次包括 3 个特质，分别是序列（Seq）、映射（Map）和集合（Set），混入这 3

个特质的容器最大的区别是其元素的索引方式，序列是按照从 0 开始的整数进行索引的，映射是按

照键值进行索引的，而集合是没有索引的。

4．序列

序列（Sequence）是指元素可以按照特定的顺序访问的容器。在 Scala 的容器层级中，序列的根

是 collection.Seq 特质，是对所有可变和不可变序列的抽象。序列中每个元素均带有一个从 0 开始计

数的固定索引。特质 Seq 具有两个子特质 LinearSeq 和 IndexedSeq，这两个子特质没有添加任何新的

方法，只是针对特殊情况对部分方法进行重载，以提供更高效的实现。LinearSeq 序列具有高效的 head

和 tail 操作，而 IndexedSeq 序列具有高效的随机存储操作。实现了特质 LinearSeq 的常用序列有列表

（List）和队列（Queue）。实现了特质 IndexedSeq 的常用序列有可变数组（ArrayBuffer）和向量（Vector）。

这里介绍两种常用的序列，即列表（List）和 Range。

（1）列表

列表（List）是一种共享相同类型的不可变的序列，是函数式编程中常见的数据结构之一。Scala

的列表被定义在 scala.collection.immutable 包中。不同于 Java 的 java.util.List，Scala 的列表一旦被定

义，其值就不能改变，因此，声明列表时必须初始化，示例如下。

scala> var strList=List(\"BigData\",\"Hadoop\",\"Spark\")

上面的语句定义了一个包含 3 个字符串的列表 strList。这里直接使用了 List，而无须加

scala.collection.immutable，这是因为 Scala 默认导入了 Predef 对象，而该对象为很多常用的数据类型

提供了别名定义，包括不可变列表 scala.collection.immutable.List、不可变集 scala.collection.immutable.

Set 和不可变映射 scala.collection.immutable.Map 等。不能直接用 new 关键字来创建一个列表，这里使

用了 List 的 apply( )方法创建一个列表 strList（apply( )方法将在 2.3.2 小节中介绍）。创建列表时也可以

显式指定元素类型，示例如下。

scala> val l = List[Double](1,3.4)

l: List[Double] = List(1.0,3.4)

值得注意的是，对于包括列表在内的所有容器类型，如果没有显式指定元素的类型，Scala 会自

动选择所有初始值的最近公共类型来作为元素的类型。因为 Scala 的所有对象都来自共同的根 Any，

因此，原则上容器内可以容纳任意不同类型的成员（尽管实际上很少这样做），示例如下。

scala> val x=List(1,3.4,\"Spark\")

x: List[Any] = List(1,3.4,Spark) //1、3.4、\"Spark\"的最近公共类型为 Any

列表有头部和尾部的概念，可以分别使用 head 和 tail 方法来获取，例如，strList.head 将返回字

符串\"BigData\"，strList.tail 返回 List(\"Hadoop\",\"Spark\")，即 head 返回的是列表第一个元素的值，而 tail

返回的是除第一个元素外的其他值构成的新列表，这体现出列表具有递归的链表结构。正是基于这

一点，常用的构造列表的方法是在已有列表前端增加元素，使用的操作符为“::”，示例如下。

scala> val otherList=\"Apache\"::strList

其中，strList 是前面已经定义过的列表，执行该语句后，strList 保持不变，而 otherList 将成为一

个新的列表 List(\"Apache\",\"BigData\",\"Hadoop\",\"Spark\")。注意，这里的“::”只是 List 的一个方法，

而且 Scala 规定，当方法名以冒号结尾时，可将其作为操作符使用，将执行“右结合”规则，因此，

\"Apache\"::strList 等效于 strList.::(\"Apache\")。Scala 还定义了一个空列表对象 Nil，借助 Nil 可以将多

个元素用操作符“::”连起来初始化一个列表，示例如下。

scala> val intList = 1::2::3::Nil

该语句与 val intList = List(1,2,3)等效。注意，最后的 Nil 是不能省略的，因为“::”是右结合的，

3 是 Int 类型值，它并没有名为“::”的方法。

列表作为一种特殊的序列，可以支持索引访问，例如，strList(1)返回字符串\"Hadoop\"。但是需要

33

第 2 章 Scala 语言基础

注意的是，由于列表采用链表结构，除了 head、tail 以及其他创建新链表的操作的时间复杂度是常数

时间 O(1)，其他诸如按索引访问的操作都需要从头开始遍历，因此时间复杂度是线性时间 O(N)。为

了实现所有操作的时间复杂度都是常数时间，可以使用向量（Vector），示例如下。

scala> val vec1=Vector(1,2)

vec1: scala.collection.immutable.Vector[Int] = Vector(1, 2)

scala> val vec2 = 3 +: 4 +: vec1

vec2: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2)

scala> val vec3 = vec2 :+ 5

vec3: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2, 5)

scala> vec3(3)

res6: Int = 2

上面语句中的“+:”和“:+”都是继承自特质 Seq 中的方法，用于向序列的前端和尾端添加新元

素，注意以“:”结尾的方法是右结合的。

列表和向量都是不可变的，其包含的对象一旦确定就不能增加和删除。列表和向量对应的可变

版本是 ListBuffer 和 ArrayBuffer，这两个序列都位于 scala.collection.mutable 中。下面以 ListBuffer 为

例进行说明，ArrayBuffer 的使用方法与之类似，只是其随机存储效率更高。

scala> import scala.collection.mutable.ListBuffer

scala> val mutableL1 = ListBuffer(10,20,30) //初始长度为 3 的可变列表

mutableL1: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 20, 30)

scala> mutableL1 += 40 //在列表尾部增加一个元素 40

res22: mutableL1.type = ListBuffer(10, 20, 30, 40)

scala> val mutableL2 = mutableL1:+50 //在列表尾部增加一个元素 50，并返回这个新列表，原列表保持不变

mutableL2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 20, 30, 40, 50)

scala> mutableL1.insert(2,60,40) //从第 2 个索引位置开始，插入 60 和 40

scala> mutableL1

res24: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 20, 60, 40, 30, 40)

scala> mutableL1 -= 40 //在数组中删除值为 40 的第一个元素

res25: mutableL1.type = ListBuffer(10, 20, 60, 30, 40)

scala> var temp=mutableL1.remove(2)//移除索引为 2 的元素，并将其返回

temp: Int = 60

scala> mutableL1

res26: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 20, 30, 40)

需要注意的是，+=方法会修改列表本身，而+:方法只是利用当前列表创建一个新的列表，并在

其前端增加元素，当前列表本身并未改变。为了防止混淆，可以记住一个简单的规则：对于可变序

列，包含等号“=”的方法都会直接修改序列本身，否则，就是创建新序列。例如，++=方法会将另

一个容器中的元素添加到列表尾端，而++方法执行类似操作时，则只返回新列表，并不会修改原列

表。上述规则同样适用于后文将要介绍的可变集合和可变映射。

（2）Range

Range 类是一种特殊的、带索引的不可变数字等差序列，其包含的值为从给定起点按一定步长增

大（减小）到指定终点的所有数值。可以使用两种方法创建一个 Range 对象，第一种方法是直接使

用 Range 类的构造器，示例如下。

scala> val r=new Range(1,5,1)

其中，第一个参数为起点，第二个参数为终点（终点本身不会被包含在创建得到的 Range 对象

内），最后一个参数为步长。因此，上述语句创建的 Range 对象包括 1、2、3 和 4 共 4 个整数元素，

可以使用从 0 开始的索引访问其元素，例如，r(2)的值是 3，还可以分别使用 start 和 end 成员变量访

问其起点和终点。

第二种创建 Range 对象的常用方法是使用数值类型的 to 方法，这种方法经常使用在 for 语句中。

34

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

例如，1 to 5 这个语句将生成包含 1 到 5 的 Range；如果不想包括区间终点，可以使用 until 方法，例

如，1 until 5 这个语句会生成包含 1 到 4 的 Range；还可以设置非 1 的步长，例如，1 to 5 by 2 这个语

句将生成包含 1、3 和 5 的 Range。

类似于生成包含整数的 Range，还可以生成包含实数的等差序列。支持 Range 的类型包括 Int、

Long、Char、BigInt 和 BigDecimal 等。

5．集合

Scala 的集合（Set）是不重复元素的容器。相对于列表中的元素是按照索引顺

序来组织的，集合中的元素并不会记录元素的插入顺序，而是以哈希算法进行组

织（不可变集在元素很少时会采用其他方式实现），所以，它可以支持快速找到某

个元素。集合包括可变集和不可变集，分别位于 scala.collection.mutable 包和

scala.collection.immutable 包，默认情况下创建的是不可变集。示例如下。

scala> var mySet = Set(\"Hadoop\",\"Spark\")

scala> mySet += \"Scala\"

其中，第 1 行创建集合的方法与创建数组和列表的方法类似，通过调用 Set 的 apply( )方法来创

建一个集合；第 2 行实际是一条赋值语句的简写形式，等效于 mySet=mySet+ \"Scala\"，即调用了 mySet

的名为“+”的方法，该方法返回一个新的集合，将这个新的集合赋值给可变变量 mySet，因此，如

果在定义变量时用 val 修饰 mySet，执行时将会出错。

如果要声明一个可变集，则需要提前引入 scala.collection.mutable.Set。举例如下。

scala> import scala.collection.mutable.Set

scala> val myMutableSet = Set(\"Database\",\"BigData\")

scala> myMutableSet += \"Cloud Computing\"

可以看出，创建可变集的方法与创建不可变集的方法是完全一样的。不过需要注意的是，这里

创建可变集代码的第 3 行与上面创建不可变集代码的第 2 行，虽然看起来形式完全一样，但是，二

者有本质的不同。回忆前文介绍的等号规则，+=方法会直接在原集合上添加一个元素。这里变量

myMutableSet 引用本身并没有改变，因为其被 val 修饰，但其指向的集合对象已经改变了。

6．映射

映射（Map）是一系列键值对的容器。在一个映射中，键（也称为 key）是唯一的，但值（也称

为 value）不一定是唯一的。可以根据键来对值进行快速的检索。Scala 提供了可变映射和不可变映射，

分别定义在包 scala.collection.mutable 和 scala.collection.immutable 里。默认情况下，Scala 使用的是

不可变映射。示例如下。

scala> val university = Map(\"XMU\" ->\"Xiamen University\", \"THU\" ->\"Tsinghua University\",

\"PKU\"->\"Peking University\")

这里定义了一个从字符串到字符串的不可变映射，在 Scala REPL 中，可以看到其类型为

scala.collection.immutable.Map[String,String]。其中，操作符“->”是二元组定义的简写方式，它会返

回一个包含调用者和传入参数的二元组，在该例中，即（String,String）类型的二元组。

如果要获取映射中的值，可以通过键来获取。对于上述实例，university(\"XMU\")将返回字符串

\"Xiamen University\"，对于这种访问方式，如果给定的键不存在，则会抛出异常，为此，访问前可以

先调用 contains( )方法来确定键是否存在。例如，在本例中，university.contains(\"XMU\")将返回 true，

但 university.contains(\"Fudan\")将返回 false。推荐的用法是使用 get( )方法，它会返回 Option[T]类型（见

2.3.3 小节中关于 Option 类的实例）。

对于不可变映射，不能添加新的键值对，也不能修改或者删除已有的键值对。对于可变映射，可

以直接修改其元素。如果想使用可变映射，必须明确地导入 scala.collection.mutable.Map。示例如下。

scala> import scala.collection.mutable.Map

scala> val university2 = Map(\"XMU\" -> \"Xiamen University\", \"THU\" -> \"Tsinghua University\",

数据结构（集合、

映射）

35

第 2 章 Scala 语言基础

\"PKU\"->\"Peking University\")

scala> university2(\"XMU\") = \"Ximan University\"

scala> university2(\"FZU\") = \"Fuzhou University\"

scala> university2 += (\"TJU\"->\"Tianjin University\")

其中，第 3 条语句修改了键为\"XMU\"的已有元素，第 4 条语句通过修改不存在的键为\"FZU\"的元

素，达到了添加新元素的目的，最后一行直接调用名为“+=”的方法增加新元素。映射的两个常用

的方法是 keys 和 values，分别用于返回由键和值构成的容器对象。

7．迭代器

迭代器（Iterator）是一种提供了按顺序访问容器元素功能的数据结构。尽管构造一个迭代器与

构造一个容器很类似，但迭代器并不是一个容器类，因为不能随机访问迭代器的元素，而只能按从

前往后的顺序依次访问其元素。因此，迭代器常用于需要对容器进行一次遍历的场景。迭代器提供

了两个基本操作，即 next( )和 hasNext( )，可以很方便地实现对容器进行遍历。next( )用于返回迭代

器的下一个元素，并从迭代器中将该元素抛弃，hasNext( )用于检测是否还有下一个元素。示例如下。

val iter = Iterator(\"Hadoop\",\"Spark\",\"Scala\")

while (iter.hasNext) {

println(iter.next())

}

上面语句执行结束后，迭代器移动到末尾，就不能再使用了，如果再执行一次 println(iter.next( ))，

就会出错，从这一点可以看出迭代器并不是一个容器，而是一个有些类似 C++中指向容器元素的指

针，但该指针不能前后随意移动，只能逐次向后一个元素一个元素地移动。实际上，调用迭代器的

大部分方法都会改变迭代器的状态，例如，调用 length( )方法会返回迭代器元素的个数，但是，调用

结束后，迭代器已经没有元素了，再次进行相关操作会出错。因此，建议除调用 next( )和 hasNext( )

方法外，在对一个迭代器调用了某个方法后，不要再次使用该迭代器。

2.3 面向对象编程基础

作为一门其程序可以运行在 JVM 上的语言，Scala 毫无疑问是面向对象的语言。尽管在具体的数

据处理部分，函数式编程在 Scala 中已成为首选方案，但在上层的架构组织上，仍然需要采用面向对象

的模型，这对于大型的应用程序必不可少。本节将对面向对象编程的基础知识进行较为详细的介绍，

包括类、对象、继承、参数化类型和特质等基本概念，以及 Scala 中应用灵活的模式匹配功能和包。

2.3.1 类

类和对象是 Java、C++等面向对象编程语言的基础概念。可以将类理解为用来创建对象的蓝图或

模板。定义好类以后，就可以使用 new 关键字来创建对象。

1．类的定义

Scala 的类用关键字 class 声明。最简单的类的定义形式如下。

class Counter{

//这里定义类的字段和方法

}

其中，Counter 是类名，Scala 中建议类名都用大写字母开头。在类的定义中，

字段和方法统称为类的成员（Member），其中，字段是指对象所包含的变量，它保存了对象的状态或

者数据，而方法是使用这些数据对对象进行各种操作的可执行程序块。Scala 中建议字段名和方法名

都采用小写字母开头。字段的定义和变量的定义一样，用 val 或 var 关键字进行定义，方法用关键字

def 定义，基本的语法格式如下。

类（类的定义）

36

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

def 方法名(参数列表):返回结果类型={方法体}

例如，下面是一个完整的类定义。

class Counter {

var value = 0

def increment(step:Int):Unit = { value += step}

def current():Int = {value}

}

在上面定义的类中，包括一个字段 value 和两个方法。其中，方法 increment( )接收一个 Int 类型

的参数，返回结果类型为 Unit；current( )方法没有参数，返回一个 Int 类型的值。与 Java 不同的是，

在 Scala 的方法中，不需要依靠 return 语句来为方法返回一个值；对 Scala 而言，方法里面的最后一

个表达式的值就是方法的返回值。有了类的定义，就可以使用 new 关键字来进行实例化，并通过实

例对类的成员进行访问。示例如下。

val myCounter = new Counter

myCounter.value = 5 //访问字段

myCounter.add(3) //调用方法

println(myCounter.current) //调用无参数方法时，可以省略方法名后的括号

Scala 允许类的嵌套定义，即在一个类的定义体里再定义另外一个类。下面在 Linux 系统中创建

一个代码文件 Top.scala，内容如下。

//代码文件为/usr/local/scala/mycode/Top.scala

class Top(name:String,subname:String){ //顶层类

case class Nested(name:String) //嵌套类

def show{

val c=new Nested(subname)

printf(\"Top %s includes a Nested %s\

\",name,c.name)

}

}

val t = new Top(\"A\",\"B\")

t.show

在 Scala REPL 中运行代码文件后，将输出“Top A includes a Nested B”。

2．类成员的可见性

在 Scala 类中，所有成员的默认可见性为公有，且不需要用 public 关键字进行限定，任何作用域内

的对象都能直接访问公有成员。除了默认的公有可见性，Scala 也提供与 Java 类似的可见性选项，包括

private 和 protected。其中，private 成员只对本类和嵌套类可见；protected 成员对本类和其继承类都可见。

Scala 不推荐将字段的可见性设置为默认的公有，而建议将其设置为私有（private）。为了实现对

这些私有字段的访问，Scala 采用类似 Java 中的 getter( )和 setter( )方法，定义了两个成对的方法 value

和 value_=，其中的 value 是需要向用户暴露的字段名字。例如，对于前面定义的 Counter 类，为了避

免直接暴露公有字段 value，可以对其进行重写。下面在 Linux 系统中创建一个代码文件 Counter.scala，

内容如下。

//代码文件为/usr/local/scala/mycode/Counter.scala

class Counter {

private var privateValue = 0

def value = privateValue

def value_=(newValue: Int){

if (newValue > 0) privateValue = newValue

}

def increment(step: Int): Unit = {value += step}

def current():Int = {value}

}

37

第 2 章 Scala 语言基础

上例中定义了一个私有字段 privateValue，该字段不能直接从外部访问，而要通过方法 value 和

value_进行访问和修改，它们相当于 Java 中的 getter( )方法和 setter( )方法。下面在 Scala REPL 中执

行如下代码。

scala> :load /usr/local/scala/mycode/Counter.scala

Loading /usr/local/scala/mycode/Counter.scala…

defined class Counter

scala> val myCounter = new Counter

myCounter: Counter = Counter@f591271

scala> myCounter.value_=(3) //为 privateValue 设置新的值

scala> println(myCounter.value) //访问 privateValue 的当前值

3

上面为了设置 privateValue 的值调用了名为“value_=”的方法，这种方式对用户显然不够友好和直

观，因此，Scala 语法中有如下规则：当编译器发现以 value 和 value_=这种成对形式出现的方法时，它允

许用户去掉下画线“_”，而采用类似赋值表达式的形式。例如，上面倒数第 3 行代码可以写为如下形式。

myCounter.value= 3 //等效于 myCounter.value_=(3)

有了该规则以后，用户访问私有字段与访问公有字段的代码，在形式上完全统一，而实际上都

调用了相应的方法。由于类的实现对用户而言是透明的，在需要的时候，可以自由地将直接暴露的

公有字段改为通过方法来访问的私有字段，或者反过来，并且不会影响用户的使用体验。

3．方法的定义方式

在 Scala 语言中，方法参数前不能加上 val 或 var 关键字来限定，所有的方法参数都是不可变类

型的，相当于隐式地使用了 val 关键字进行限定，如果在方法体里面给参数重新赋值，那么程序将不

能通过编译。对于无参数的方法，定义时可以省略括号，不过需要注意，如果定义时省略了括号，

那么在调用时也不能带括号；如果无参数方法在定义时带括号，则调用时可以带括号，也可以不带

括号。在调用方法时，方法名后面的圆括号“( )”可以用花括号“{}”来代替。另外，如果方法只有

一个参数，可以省略点号“.”而采用中缀调用法，形式为“调用者 方法名 参数”。例如，现在对上

面定义的 Counter 类进行改写，改写后的代码保存为 Counter1.scala，具体代码如下。

//代码文件为/usr/local/scala/mycode/Counter1.scala

class Counter {

var value = 0

def increment(step:Int):Unit = {value += step}

def current:Int= value

def getValue():Int = value

}

在这种定义下，对 current 方法的调用不能带括号，对 getValue( )方法的调用可带也可不带括号。

下面在 Scala REPL 中通过实例测试各种调用方式的效果。

scala> :load /usr/local/scala/mycode/Counter1.scala

Loading /usr/local/scala/mycode/Counter1.scala…

defined class Counter

scala> val c=new Counter

c: Counter = Counter@30ab4b0e

scala> c increment 5 //中缀调用法

scala> c.getValue() //getValue()定义中有括号，可以带括号调用

res0: Int = 5

scala> c.getValue //getValue()定义中有括号，也可不带括号调用

res1: Int = 5

scala> c.current() //current 定义中没有括号，不可带括号调用

<console>:13: error: Int does not take parameters

38

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

c.current()

^

scala> c.current //current 定义中没有括号，只能不带括号调用

res3: Int = 5

当方法的返回结果类型可以从最后的表达式推断出时，方法定义中可以省略返回结果类型，同

时，如果方法体只有一条语句，还可以省略方法体两边的花括号。示例如下。

class Counter {

var value = 0

def increment(step:Int) = value += step //赋值表达式的值为 Unit 类型值

def current()= value //根据 value 的类型自动推断出返回结果类型为 Int 类型

}

另外，如果方法的返回结果类型为 Unit，可以同时省略返回结果类型和等号，但花括号不能省

略。因此，上面的例子还可以改写如下。

class Counter {

var value = 0

def increment(step:Int) { value += step }

def current()= value

}

在定义一个方法时，如果只是为了获得方法的“副作用”（如输出信息），那么可以采用省略等

号的定义方式，这时的方法就相当于其他语言中的过程（Procedure）。值得注意的是，在这种情况下，

不管方法体的最后一句表达式的类型是什么，返回结果类型都是 Unit，因为 Scala 编译器可以将任

何类型转换为 Unit。因此，对一个方法而言，当我们希望通过类型推断让方法返回正确值时，如果

不小心漏写了等号，就会导致方法不能得到正确的返回值。

在 Java 及 C++中，方法声明中的参数名对调用者是没有意义的。但是，在 Scala 中，调用方法

时可以显式地使用命名参数列表。当方法有多个默认值，而调用者只给出与默认值个数不同的参数

时，这一规则将使程序更简洁，可读性更强。示例如下。

class Position(var x:Double=0,var y:Double=0) {

def move(deltaX:Double=0,deltaY:Double=0) {

x+=deltaX;

y+=deltaY

}

}

val p=new Position()

p.move(deltaY=5) //沿 y 轴移动 5 个单位，deltaX 采用了默认值

Scala 允许方法重载。只要方法的完整签名是唯一的，多个方法可以使用相同的方法名。方法的

签名包括方法名、参数类型列表、返回结果类型。另外，如果方法定义包含参数列表，方法名可以

与类的字段同名。例如，下面的定义是合法的。

class Temp{

var x:Int = 0 //这里使用“x”作为字段名

def x(i:Int):Int=x+I //这里又使用“x”作为方法名

}

Scala 允许方法的嵌套定义，即在一个方法体里再定义另一个方法。示例如下。

def sumPowersOfTwo(a: Int, b: Int): Int = {

def powerOfTwo(x: Int): Int = {if(x == 0) 1 else 2 * powerOfTwo(x-1)}

if(a > b) 0 else powerOfTwo(a) + sumPowersOfTwo(a+1, b)

}

这里，sumPowersOfTwo 用于实现求 2 的从 a 到 b 次幂的和，该方法先定义了一个嵌套方法

powerOfTwo 来实现求 2 的整数次幂，然后递归调用该方法。嵌套方法仅在其定义的方法里面可见，

39

第 2 章 Scala 语言基础

例如，在上例中，不能在 sumPowersOfTwo 外部访问 powerOfTwo( )方法。

4．构造器

在 Scala 中，整个类的定义主体就是类的构造器，称为主构造器，所有位于类

方法以外的语句都将在构造过程中被执行。可以像定义方法参数一样，在类名之

后用圆括号列出主构造器的参数列表。例如，可以给前文中定义的 Counter 类提供

一个字符串参数，代码如下。

class Counter(name: String) {

private var value = 0

def increment(step: Int): Unit = { value += step}

def current(): Int = {value}

def info(): Unit = {printf(\"Name:%s\",name)}

}

除了主构造器，Scala 还可以包含 0 个或多个辅助构造器（Auxiliary Constructor）。辅助构造器使

用 this 进行定义，this 的返回结果类型为 Unit。每个辅助构造器的第一个表达式必须是调用一个此前

已经定义的辅助构造器或主构造器，调用的形式为“this(参数列表)”。这个规则意味着，每一个 Scala

辅助构造器最终都始于对类的主构造器的调用。下面新建一个代码文件 Counter2.scala，内容如下。

//代码文件为/usr/local/scala/mycode/Counter2.scala

class Counter {

private var value = 0

private var name = \"\"

private var step = 1 //Counter 的默认递进步长

println(\"the main constructor\") //属于主构造器的语句

def this(name: String){ //第一个辅助构造器

this() //调用主构造器

this.name = name

printf(\"the first auxiliary constructor,name:%s\

\",name)

}

def this (name: String,step: Int){ //第二个辅助构造器

this(name) //调用前一个辅助构造器

this.step = step

printf(\"the second auxiliary constructor,name:%s,step:%d\

\",name,step)

}

def increment(step: Int): Unit = { value += step}

def current(): Int = {value}

}

下面新建类的对象，可以观察到主构造器和两个辅助构造器分别被调用，在 Scala REPL 中执行

如下代码。

scala> :load /usr/local/scala/mycode/Counter2.scala

Loading /usr/local/scala/mycode/Counter2.scala…

defined class Counter

scala> val c1=new Counter

the main constructor

c1: Counter = Counter@319c6b2

scala> val c2=new Counter(\"the 2nd Counter\")

the main constructor

the first auxiliary constructor,name:the 2nd Counter

c2: Counter = Counter@4ed6c602

scala> val c3=new Counter(\"the 3nd Counter\",2)

类（构造器）

40

Spark 编程基础（Scala 版 第 2 版）（附微课视频）

the main constructor

the first auxiliary constructor,name:the 3nd Counter

the second auxiliary constructor,name:the 3nd Counter,step:2

c3: Counter = Counter@64fab83b

与类方法参数不同的是，主构造器的参数前可以使用 val 或 var 关键字。如果主构造器中使用 val

或 var 关键字修饰参数，Scala 内部将自动为这些参数创建私有字段，并通过前文提到的字段访问规

则提供对应的访问方法，示例如下。

scala> class Counter(var name:String) //定义一个带字符串参数的简单类

defined class Counter

scala> var mycounter = new Counter(\"Runner\")

mycounter: Counter = Counter@17fcc4f7

scala> println(mycounter.name) //调用读方法

Runner

scala> mycounter.name_=(\"Timer\") //调用写方法

scala> mycounter.name = \"Timer\" //更直观地调用写方法，和上句等效

mycounter.name: String = Timer

如果参数是用 val 关键字声明的，则只会生成读方法，而不会生成写方法。如果不希望让构造器

参数成为类的字段，只需要省略关键字 var 或者 val，在这种情况下，构造器参数在构造器退出后将

被丢弃，对用户不再可见。

2.3.2 对象

1．单例对象

Scala 类中没有 Java 那样的静态成员。Scala 采用单例对象（Singleton Object）

来实现与 Java 静态成员同样的功能。单例对象的定义与类定义类似，只是用 object

关键字替换了 class 关键字。示例如下。

//代码文件为/usr/local/scala/mycode/Person.scala

object Person {

private var lastId = 0 //一个人的身份编号

def newPersonId() = {

lastId +=1

lastId

}

}

有了这个单例对象，就可以直接通过其名字使用它，就像使用一个普通的类实例一样。将上面

的代码保存到文件 Person.scala 中，然后在 Scala REPL 中执行如下代码。

scala> :load /usr/local/scala/mycode/Person.scala

Loading /usr/local/scala/mycode/Person.scala…

defined object Person

scala> printf(\"The first person id: %d.\

\",Person.newPersonId())

The first person id: 1.

scala> printf(\"The second person id：%d.\

\",Person.newPersonId())

The second person id：2.

scala> printf(\"The third person id: %d.\

\",Person.newPersonId())

The third person id: 3.

单例对象在第一次被访问的时候初始化。需要强调的是，定义的是单例对象而不是类型，即不

能实例化 Person 类型的变量，这也是其被称为“单例”的原因。单例对象包括两种，即伴生对象（Companion

Object）和孤立对象（Standalone Object）。当一个单例对象和它的同名类一起出现时，这时的单例对

对象（单例对象）