Hadoop+Spark大数据技术（自命题试卷测试）

试卷一

一、选择题 (每小题2分，共20分)

1. Hadoop 核心组件包括：
    A. HDFS 和 Hive
    B. HDFS 和 MapReduce
    C. HBase 和 Spark
    D. YARN 和 ZooKeeper

2. HDFS 数据块存储方式的优势不包括：
    A. 文件大小不受单一磁盘大小限制
    B. 简化存储过程
    C. 提高数据访问速度
    D. 提高数据容错能力

3. NameNode 的主要功能是：
    A. 存储数据块
    B. 处理数据读写请求
    C. 管理文件系统命名空间和元数据
    D. 备份 NameNode 的元数据

4. MapReduce 中的 Reduce 函数的输入是：
    A. 原始数据
    B. 中间结果
    C. 最终结果
    D. 数据块

5. HBase 与传统关系型数据库的主要区别在于：
    A. 数据类型
    B. 数据操作
    C. 存储模式
    D. 以上所有

6. Spark 生态系统不包括：
    A. Spark Core
    B. Spark SQL
    C. Spark Streaming
    D. Spark Hive

7. RDD 的概念是：
    A. 可变的分布式数据集
    B. 只读的分区记录集合
    C. 可扩展的机器学习库
    D. 分布式图处理框架

8. Spark 中的 Transformation 操作的特点是：
    A. 立即执行
    B. 惰性计算
    C. 返回结果
    D. 改变原 RDD

9. DataFrame 与 Dataset 的主要区别在于：
    A. 数据类型
    B. 操作接口
    C. 存储方式
    D. 以上所有

10. Spark Streaming 的基本理念是：
    A. 批量处理数据
    B. 实时处理数据流
    C. 处理静态数据集
    D. 离线数据分析

二、判断题 (每小题2分，共20分)

1. Hadoop 只能部署在 Linux 系统上。 ( )
2. HDFS 支持在文件任意位置修改数据。 ( )
3. SecondaryNameNode 可以完全替代 NameNode。 ( )
4. MapReduce 是一种分布式并行计算编程模型。 ( )
5. HBase 的数据存储模式是基于行存储的。 ( )
6. Spark SQL 只能处理结构化数据。 ( )
7. Spark Streaming 只能处理实时数据。 ( )
8. RDD 之间的依赖关系分为窄依赖和宽依赖。 ( )
9. DataFrame 和 Dataset 都支持类型推断。 ( )
10. Spark Streaming 的核心组件是 Spark Core。 ( )

三、简答题 (每小题5分，共20分)

1. 简述 Hadoop 的三种运行模式及其特点。
2. 描述 HDFS 的存储架构，并说明各个组件的功能。
3. 简述 MapReduce 的工作原理，并以 WordCount 为例说明其执行流程。
4. 说明 HBase 数据表的物理视图，并解释各个维度的含义。

四、程序分析题 (第1-5小题各6分，第6题10分，共40分)

1. 解释以下 Scala 代码的含义：
```scala
val numbers = List(1, 2, 3, 4)
val doubled = numbers.map(x => x * 2)
```

2. 写出创建名为 "student" 的 HBase 表的命令，该表包含两个列族 "baseinfo" 和 "score"，版本数均为 2。

3. 使用 Spark SQL 创建一个包含 "name" 和 "age" 列的 DataFrame，数据源为以下列表：
```scala
val list = List( ("zhang" , "18") , ("wang" , 17) , ("LI" , 20) )
```

4. 写出使用 Spark Streaming 读取数据流并进行词频统计的代码片段。

5. 描述 Spark 中 RDD 之间的窄依赖和宽依赖，并解释其区别。

试卷一参考答案

一、选择题 (每小题2分，共20分)

1. B. HDFS 和 MapReduce
   Hadoop 的核心组件是 HDFS (Hadoop Distributed File System) 和 MapReduce (分布式并行计算编程模型)。
2. C. 提高数据访问速度
   HDFS 数据块存储方式的优势在于文件大小不受单一磁盘大小限制，简化存储过程，提高数据容错能力，但不一定能提高数据访问速度。
3. C. 管理文件系统命名空间和元数据
   NameNode 是 HDFS 的中心服务器，负责管理文件系统命名空间和元数据，包括文件权限、所有者、副本数和目录结构等。
4. B. 中间结果
   Reduce 函数的输入是 Map 函数的输出，即中间结果。
5. D. 以上所有
   HBase 与传统关系型数据库在数据类型、数据操作、存储模式等方面都有明显区别。
6. D. Spark Hive
   Spark 生态系统包括 Spark Core、Spark SQL、Spark Streaming、Spark MLlib、Spark GraphX 等。
7. B. 只读的分区记录集合
   RDD (Resilient Distributed Dataset) 是 Spark 对数据的抽象，它是一个只读的分区记录集合。
8. B. 惰性计算
   Transformation 操作是惰性计算的，只有在执行 Action 操作时才会真正执行。
9. D. 以上所有
   DataFrame 和 Dataset 在数据类型、操作接口、存储方式等方面都有区别。
10. A. 批量处理数据
    Spark Streaming 的基本理念是实时处理数据流，而不是批量处理数据。

二、判断题 (每小题2分，共20分)

1. 错误。 Hadoop 可以部署在多种操作系统上，包括 Linux、Windows 和 macOS 等。
2. 错误。 HDFS 支持在文件末端追加数据，但不支持在文件任意位置修改数据。
3. 错误。 SecondaryNameNode 是 NameNode 的辅助节点，不能完全替代 NameNode。
4. 正确。 MapReduce 是一种分布式并行计算编程模型，它将大规模数据处理任务分解成多个 Map 和 Reduce 任务，并行执行。
5. 错误。 HBase 的数据存储模式是基于列存储的，而不是行存储。
6. 错误。 Spark SQL 可以处理结构化数据和半结构化数据。
7. 错误。 Spark Streaming 可以处理实时数据和历史数据。
8. 正确。 RDD 之间的依赖关系分为窄依赖和宽依赖，它们影响着 Spark 的数据处理效率。
9. 错误。 DataFrame 支持类型推断，但 Dataset 比 DataFrame 更能方便地进行类型推断。
10. 错误。 Spark Streaming 是 Spark 生态系统的一部分，它的核心组件是 Spark Core。

三、简答题 (每小题5分，共20分)

1. Hadoop 的三种运行模式：
   • 单机模式： 在一台机器上运行，本地文件系统存储，适用于开发阶段调试 MapReduce 程序。
   • 伪分布式模式： 在一台机器上模拟分布式环境，读取 HDFS 文件，适合测试和学习。
   • 分布式模式： 在多个节点上构建集群，实现真正的分布式数据存储和处理。
2. HDFS 的存储架构：
   HDFS 采用主从架构，主要组件包括：
   • Client： 客户端，负责与 NameNode 和 DataNode 交互，执行文件操作。
   • NameNode： 命名节点，负责管理文件系统命名空间和元数据，处理文件访问请求。
   • DataNode： 数据节点，负责存储数据块，处理数据读写请求。
   • SecondaryNameNode： 辅助命名节点，负责备份 NameNode 的元数据，以便失效恢复。
3. MapReduce 的工作原理：

        MapReduce 将大规模数据处理任务分解成多个 Map 和 Reduce 任务，并行执行。

        Map 任务： 读取输入数据，进行处理并生成中间结果。

        Reduce 任务： 接收 Map 任务的中间结果，进行聚合操作并生成最终结果。

        WordCount 示例： 读取文本文件，将每个单词作为 key，出现次数作为 value，进行统计。

4.HBase 数据表的物理视图：
HBase 数据表以键值对形式保存数据，在四个维度上进行组织：

• 行键 (Row Key)： 每行数据的唯一标识，用于定位数据。
• 列族 (Column Family)： 一组相关的列，数据按照列族进行存储。
• 列名 (Column Name)： 列族中的具体列名，用于访问数据。
• 时间戳 (Time Stamp)： 数据的版本信息，用于区分不同时间的数据。

四、程序分析题 (第1-5小题各6分，第6题10分，共40分)

1.解释以下 Scala 代码的含义：

val numbers = List(1, 2, 3, 4)
val doubled = numbers.map(x => x * 2)

• val numbers = List(1, 2, 3, 4)：定义一个名为 numbers 的不可变列表，包含元素 1、2、3、4。
• val doubled = numbers.map(x => x * 2)：使用 map 函数对 numbers 列表进行转换，将每个元素乘以 2，并生成一个新的列表 doubled，包含元素 2、4、6、8。
• x => x * 2：这是一个匿名函数，它接收一个参数 x，并返回 x 乘以 2 的结果。

2.写出创建名为 "student" 的 HBase 表的命令，该表包含两个列族 "baseinfo" 和 "score"，版本数均为 2。

create 'student',{NAME=>'baseinfo',VERSION=>2},{NAME=>'score',VERSION=>2}

3.使用 Spark SQL 创建一个包含 "name" 和 "age" 列的 DataFrame，数据源为以下列表：

val list = List( ("zhang" , "18") , ("wang" , 17) , ("LI" , 20) )

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder()
  .appName("DataFrameExample")
  .getOrCreate()

val df = spark.sparkContext.parallelize(list).toDF("name", "age")

4.写出使用 Spark Streaming 读取数据流并进行词频统计的代码片段。

import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.dstream.ReceiverInputDStream

object WordCountStreaming {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("WordCountStreaming")
    val ssc = new StreamingContext(sparkConf, Seconds(1))

    // 从 socket 读取数据流
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)

    // 对每个批次数据进行词频统计
    val wordCounts: DStream[(String, Int)] = lines.flatMap(_.split(" "))
      .map((_, 1))
      .reduceByKey(_ + _)

    // 打印结果
    wordCounts.print()

    ssc.start()
    ssc.awaitTermination()
  }
}

5.描述 Spark 中 RDD 之间的窄依赖和宽依赖，并解释其区别。

• 窄依赖： 父 RDD 最多被一个子 RDD 使用，一个子 RDD 对应多个父 RDD。例如：map、filter、union 等操作会产生窄依赖。
• 宽依赖： 父 RDD 可被多个子 RDD 使用，一个子 RDD 可对应所有父 RDD。例如：reduceByKey、join 等操作会产生宽依赖。
• 区别： 窄依赖可以进行高效的并行计算，因为父 RDD 的分区只会被一个子 RDD 处理。而宽依赖需要进行数据洗牌，将数据重新分区，导致计算效率降低。

试卷二

一、选择题（每小题2分，共20分）

1. Hadoop的核心不包括以下哪个部分？
   A. HDFS
   B. MapReduce
   C. YARN
   D. ZooKeeper

2. 在Hadoop的哪种模式下，所有应用程序都在单个JVM上执行，最适合开发阶段？
   A. 单机模式
   B. 伪分布式模式
   C. 分布式模式
   D. 集群模式

3. HDFS中文件的默认数据块大小在Hadoop 2.x版本是？
   A. 64MB
   B. 128MB
   C. 256MB
   D. 512MB

4. 关于SecondaryNameNode，下列哪个描述是准确的？
   A. 它是一个备份NameNode，直接承担NameNode的工作。
   B. 它定期合并FsImage和EditLog，帮助NameNode减少启动时间。
   C. SecondaryNameNode存储了HDFS的元数据。
   D. 它直接处理客户端的文件访问请求。

5. MapReduce设计理念中，“计算向数据靠拢”是为了优化什么？
   A. 网络带宽使用
   B. 硬盘读写速度
   C. CPU利用率
   D. 内存分配

6. 关于HBase与传统关系数据库的区别，下列哪项不正确？
   A. HBase仅有字符串数据类型。
   B. HBase支持行级别的事务。
   C. HBase是基于列族存储，而传统数据库基于行存储。
   D. HBase天然支持水平扩展，而传统数据库扩展较为困难。

7. 在Scala中，下面哪个特性不是Scala的特点？
   A. 函数式编程
   B. 不支持并发编程
   C. 可以与Java代码无缝集成
   D. 支持面向对象编程

8. Spark Streaming的最小处理单位时间间隔被称为？
   A. Batch Interval
   B. Tick Time
   C. Sliding Interval
   D. Latency

9. 创建DataFrame最直接的方式是从哪个对象转换而来？
   A. RDD
   B. Dataset
   C. CSV文件
   D. Hive表

10. 关于Spark SQL的DataFrame和Dataset，哪个描述是错误的？
    A. DataFrame是基于RDD的结构化数据集。
    B. Dataset具有更严格的类型检查。
    C. DataFrame操作不如Dataset高效，因为它需要进行隐式类型转换。
    D. Dataset在编译时期就能发现类型错误。

二、判断题（每小题2分，共20分）

1. Hadoop的伪分布式模式在单个节点上运行多个守护进程，模拟分布式环境。（ ）
2. HDFS的设计不适合频繁修改的数据。（ ）
3. MapReduce的Map函数可以有多个输入参数。（ ）
4. 在HDFS中，NameNode负责数据块的存储。（ ）
5. HBase直接使用HDFS作为存储层，依赖于其高可靠性和扩展性。（ ）
6. Scala的Unit类型相当于Java中的void。（ ）
7. Spark Streaming可以从Kafka、Flume等实时数据源中读取数据。（ ）
8. 在Scala中，匿名函数不能作为参数传递给其他函数。（ ）
9. DataFrame比Dataset更灵活，因为它不要求强类型。（ ）
10. Spark在Local模式下运行时，不能进行有效的分布式计算。（ ）

三、简答题（每小题5分，共20分）

1. 解释Hadoop的三个运行模式及其应用场景。

2. 简述HDFS的容错机制是如何工作的。

3. MapReduce编程模型中的Map和Reduce函数的基本职责是什么？

4. 列举并解释HBase与传统关系数据库在存储模式上的主要区别。

四、程序分析题（共40分）

1. 分析MapReduce的WordCount示例程序中，Mapper和Reducer的工作流程。（6分）

2. 编写一个简单的Scala函数，该函数接受一个整数列表，返回这个列表的平均值。（6分）

3. 解释如何在HBase中创建一个表，并添加一条数据记录。（6分）

4. 在Spark中，如何使用Spark SQL创建一个DataFrame，并对其中的数据进行简单的过滤操作？（6分）

5. 给出一个Scala匿名函数的例子，该函数用于判断一个字符串是否全部由数字组成。

试卷二参考答案

一、选择题

1. C. YARN - 正确，YARN是Hadoop 2.x之后的资源管理框架，但不是Hadoop的核心组成部分，HDFS和MapReduce才是。
2. A. 单机模式 - 正确，单机模式下所有程序都在单个JVM上执行，适合开发调试。
3. B. 128MB - 正确，Hadoop 2.x的默认数据块大小是128MB。
4. B. 它定期合并FsImage和EditLog，帮助NameNode减少启动时间 - 正确，SecondaryNameNode帮助合并编辑日志和文件系统镜像，减小NameNode启动时间。
5. A. 网络带宽使用 - 正确，计算向数据靠拢减少了大规模数据移动，优化了网络带宽。
6. B. HBase支持行级别的事务 - 错误，HBase确实支持一定程度的事务性操作，特别是对于单行事务，这是正确的描述，所以题目表述不精确，但基于题目要求选择错误项，其他选项更明显错误。
7. B. 不支持并发编程 - 错误，Scala支持并发编程，特别是通过Actor模型。
8. A. Batch Interval - 正确，Spark Streaming处理数据的最小时间间隔称为Batch Interval。
9. A. RDD - 正确，DataFrame可以直接从RDD转换而来。
10. C. DataFrame操作不如Dataset高效，因为它需要进行隐式类型转换 - 错误，DataFrame操作也是高效的，尽管它在编译时不如Dataset类型安全，但并不意味着效率低下。

二、判断题

1. √ - 正确，伪分布式模式在单节点模拟了分布式环境。
2. √ - 正确，HDFS设计为适合大量数据的一次写入多次读取，不鼓励频繁修改。
3. × - 错误，Map函数接受单个输入值。
4. × - 错误，NameNode不负责数据块的存储，它管理文件系统的命名空间和元数据。
5. √ - 正确，HBase直接使用HDFS存储数据，利用其高可靠性和扩展性。
6. √ - 正确，Scala的Unit类型与Java的void相似，表示无返回值。
7. √ - 正确，Spark Streaming可以接入多种实时数据源。
8. × - 错误，匿名函数可以作为参数传递给其他函数，是函数式编程的重要特性。
9. × - 错误，DataFrame在类型安全性和编译时检查上不如Dataset严格。
10. × - 错误，Local模式虽运行在单机，但仍可用于分布式计算的测试和理解基本原理。

三、简答题

1. Hadoop的三个运行模式：

   单机模式用于快速测试，不涉及分布式；
   伪分布式模式在单节点上模拟分布式环境，适合开发和测试；
   分布式模式是在多节点上部署，实现真正的分布式计算，适用于生产环境。

2. HDFS容错机制：
   通过数据块的冗余副本机制，每个数据块默认有3个副本分布在不同的节点上。
   如果某个DataNode失效，NameNode会自动从其他副本中重新复制数据块，确保数据的可靠性。

3. MapReduce的Map和Reduce职责：
   Map阶段将输入数据分割成小块，对每一小块应用Map函数，生成一系列的中间键值对；Reduce阶段将相同键的所有中间值聚合，应用Reduce函数，汇总结果。

4. HBase与传统数据库存储模式区别：
   HBase基于列族存储，数据按列族组织，而传统数据库按行存储；
   HBase适合大数据量的随机访问和分析，不支持复杂的事务，而传统数据库支持行级事务和复杂的SQL查询。

四、程序分析题

1. 分析MapReduce的WordCount示例程序中，Mapper和Reducer的工作流程。（6分）

Mapper工作流程：

1. 读取输入数据： Mapper从HDFS中读取数据块，并将其解析成一行行的文本。
2. 分割单词： Mapper将每行文本进行分割，得到每个单词。
3. 生成键值对： Mapper将每个单词作为key，1作为value，生成一个键值对。
4. 输出中间结果： Mapper将生成的键值对输出到中间文件，并将中间文件写入到HDFS。

Reducer工作流程：

1. 读取中间结果： Reducer从HDFS中读取Mapper生成的中间文件。
2. 聚合操作： Reducer将相同key的value值进行累加，统计每个单词出现的次数。
3. 输出最终结果： Reducer将最终的统计结果输出到HDFS中。

2. 编写一个简单的Scala函数，该函数接受一个整数列表，返回这个列表的平均值。（6分）

def calculateAverage(numbers: List[Int]): Double = {
  if (numbers.isEmpty) 0.0
  else numbers.sum.toDouble / numbers.length
}

3. 解释如何在HBase中创建一个表，并添加一条数据记录。（6分）

创建表：

create 'tableName', {NAME => 'columnFamily1', VERSION => 1}, {NAME => 'columnFamily2', VERSION => 1}

• tableName：表的名称。
• columnFamily1 和 columnFamily2：列族名称。
• VERSION => 1：版本号，表示每个列可以保存一个版本的数据。

添加数据：

put 'tableName', 'rowKey', 'columnFamily1:columnName', 'value'

• rowKey：行键，用于定位数据。
• columnFamily1:columnName：列名，使用 : 分隔列族和列名。
• value：数据值。

4. 在Spark中，如何使用Spark SQL创建一个DataFrame，并对其中的数据进行简单的过滤操作？（6分）

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions._

val spark = SparkSession.builder()
  .appName("DataFrameExample")
  .getOrCreate()

val df = spark.read.format("json").load("path/to/data.json")

// 过滤操作，筛选age大于18的数据
val filteredDf = df.filter(col("age") > 18)

filteredDf.show()

5.给出一个Scala匿名函数的例子，该函数用于判断一个字符串是否全部由数字组成。（6分）

val isNumeric = (str: String) => str.forall(_.isDigit) 

• isNumeric：匿名函数的名称。
• str: String：函数的参数，一个字符串。
• str.forall(_.isDigit)：使用 forall 方法判断字符串中的所有字符是否都是数字。

试卷三

一、选择题 (每小题2分，共20分)

1. Hadoop 的核心组件是：
   A. HDFS 和 MapReduce
   B. Hive 和 Pig
   C. Spark 和 Storm
   D. Kafka 和 Zookeeper

2. HDFS 的数据块大小默认是：
   A. 64MB
   B. 128MB
   C. 256MB
   D. 512MB

3. MapReduce 的核心思想是：
   A. 并行计算
   B. 分布式存储
   C. 数据压缩
   D. 数据加密

4. 下列哪个选项不是 Hadoop 的运行模式：
   A. 单机模式
   B. 伪分布式模式
   C. 集群模式
   D. 云模式

5. HDFS 中的 NameNode 主要负责：
   A. 存储数据块
   B. 处理数据读写请求
   C. 管理命名空间和元数据
   D. 备份数据块

6. MapReduce 中的 Map 函数的作用是：
   A. 将数据进行排序
   B. 将数据进行分组
   C. 将数据进行转换
   D. 将数据进行汇总

7. 在 WordCount 程序中，Map 函数的输出结果是：
   A. <单词，出现次数>
   B. <偏移量，单词>
   C. <文件名称，单词>
   D. <单词，文件名称>

8. 下列哪个选项不是分布式编程的主要特征：
   A. 分布
   B. 通信
   C. 安全
   D. 并行

9. HDFS 的数据块存储模式的优点是：
   A. 提高数据访问速度
   B. 减少元数据的数量
   C. 加强数据安全性
   D. 降低存储成本

10. SecondaryNameNode 主要负责：
    A. 备份 NameNode 的元数据
    B. 处理客户端的请求
    C. 存储数据块
    D. 管理 DataNode

二、判断题 (每小题2分，共20分)

1. Hadoop 是一种分布式文件系统。 ( )
2. HDFS 允许在任意位置修改文件内容。 ( )
3. MapReduce 的设计理念是“数据向计算靠拢”。 ( )
4. MapReduce 中的 Reduce 函数接收一个列表，一个初始参数和一个函数，并返回结果。 ( )
5. DataNode 存储数据块的备份，每个 DataNode 最多存储一个备份。 ( )
6. WordCount 程序可以统计文件中每个单词的出现次数。 ( )
7. Hadoop 的单机模式适合用于生产环境。 ( )
8. HDFS 的数据块大小可以根据实际情况进行调整。 ( )
9. NameNode 是 HDFS 的中心服务器，负责管理整个文件系统的命名空间和元数据。 ( )
10. MapReduce 的执行流程是：大数据 -> Map 函数 -> Reduce 函数 -> 最终结果。 ( )

三、简答题 (每小题5分，共20分)

1. 简述 Hadoop 的优势。
2. 简述 HDFS 的基本特征。
3. 简述 MapReduce 的工作原理。
4. 简述 WordCount 程序的执行过程。

四、程序分析题 (第1-5小题各6分，第6题10分，共40分)

1. scala编写一个 MapReduce 程序，统计一个文本文件中每个单词的出现次数。
2. scala编写一个 MapReduce 程序，计算一个文本文件中所有数字的平均值。
3. scala编写一个 MapReduce 程序，将一个文本文件中的所有行进行反转。
4. scala编写一个 MapReduce 程序，统计一个文本文件中每个单词的长度。
5. scala编写一个 MapReduce 程序，统计一个文本文件中所有行的数量。

试卷三参考答案

一、选择题 (每小题2分，共20分)

1. A. HDFS 和 MapReduce

   • Hadoop 的核心组件是 HDFS（Hadoop Distributed File System，分布式文件系统）和 MapReduce（分布式并行计算编程模型），它们共同构成了 Hadoop 的基础。

2. B. 128MB

   • 在 Hadoop 2.x 版本中，HDFS 的数据块大小默认是 128MB。

3. A. 并行计算

   • MapReduce 的核心思想是将大规模数据集切分成多个独立的小数据集，然后由多个 Map 任务并行处理，最后通过 Reduce 任务将结果汇总，从而实现高效的数据处理。

4. D. 云模式

   • Hadoop 的三种运行模式分别是单机模式、伪分布式模式和分布式模式。云模式是将 Hadoop 部署在云平台上的一种方式，并不属于 Hadoop 本身的运行模式。

5. C. 管理命名空间和元数据

   • NameNode 是 HDFS 的中心服务器，负责管理整个文件系统的命名空间和元数据，包括文件的权限、所有者、副本数以及目录结构等信息。

6. C. 将数据进行转换

   • Map 函数的目的是将输入数据转换为键值对，以便后续的 Reduce 函数进行处理。

7. A. <单词，出现次数>

   • 在 WordCount 程序中，Map 函数将文本文件中的每个单词作为键，出现次数作为值，输出为 <单词，出现次数> 的键值对。

8. C. 安全

   • 分布式编程的主要特征是分布、通信和并行。安全是分布式系统需要考虑的一个重要因素，但不是其主要特征。

9. B. 减少元数据的数量

   • HDFS 的数据块存储模式将文件分割成大小相同的数据块，每个数据块只记录少量元数据，从而减少了元数据的数量，提高了存储效率。

10. A. 备份 NameNode 的元数据

    • SecondaryNameNode 主要负责备份 NameNode 的元数据，包括 FsImage 和 EditLog，以便在 NameNode 发生故障时能够快速恢复。

二、判断题 (每小题2分，共20分)

1. √
2. ×
   • HDFS 是一种一次写入多次读取的文件系统，不支持在任意位置修改文件内容。
3. ×
   • MapReduce 的设计理念是“计算向数据靠拢”，即让计算任务靠近数据存储位置，减少数据传输开销。
4. √
5. √
6. √
7. ×
   • 单机模式适合用于开发和调试，不适合生产环境。
8. √
   • HDFS 的数据块大小可以通过配置参数进行调整。
9. √
10. √

三、简答题 (每小题5分，共20分)

1. Hadoop 的优势：

   • 高可靠性： 采用冗余副本机制，保证数据安全性和可用性。
   • 高扩展性： 可以部署在数量庞大的节点集群上，处理海量数据。
   • 高效性： 并行处理数据，提高数据处理速度。
   • 低成本： 可以部署在廉价服务器集群上，降低硬件成本。

2. HDFS 的基本特征：

   • 大规模数据分布存储： 基于大量分布式节点上的本地文件系统，构成逻辑上具有巨大容量的分布式文件系统。
   • 流式访问： 批量处理数据，提高数据吞吐率。
   • 容错： 可以正确处理故障，确保数据处理继续进行，且不丢失数据。
   • 简单的文件模型： 一次写入，多次读取，支持在文件末端追加数据。
   • 数据块存储模式： 将文件分割成大小相同的数据块，减少元数据的数量。
   • 跨平台兼容性： 采用 JAVA 语言，支持 JVM 的机器都可以运行 HDFS。

3. MapReduce 的工作原理：

   • Map 任务： 将输入数据切分成多个小数据集，每个 Map 任务负责处理一个数据集，并输出中间结果。
   • Reduce 任务： 将 Map 任务输出的中间结果进行汇总，并输出最终结果。
   • 执行流程： 大数据 -> Map 任务 -> Reduce 任务 -> 最终结果。
   • 核心思想： 分而治之，将大规模计算任务分解成多个小的并行计算任务。

4. WordCount 程序的执行过程：

   • Map 任务： 读取文本文件，将每个单词作为键，出现次数作为值，输出为 <单词，出现次数> 的键值对。
   • Reduce 任务： 收集所有 Map 任务输出的 <单词，出现次数> 键值对，将相同单词的出现次数累加，并输出最终结果。
   • 最终结果： 输出每个单词的出现次数。

四、程序分析题 (第1-5小题各6分，第6题10分，共40分)

1. 统计单词出现次数

import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Word Count")
    val sc = new SparkContext(conf)
    
    val textFile = "path/to/your/textfile.txt"
    val counts = sc.textFile(textFile)
      .flatMap(line => line.split("\\W+")) // 分割单词
      .map(word => (word, 1)) // 映射每个单词到键值对
      .reduceByKey(_ + _) // 对相同单词的计数求和
    
    counts.foreach(println) // 打印结果
  }
}

2. 计算所有数字的平均值

这个任务稍微复杂一些，因为需要先识别出文本中的数字。

import org.apache.spark.{SparkConf, SparkContext}

object AverageOfNumbers {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Average of Numbers")
    val sc = new SparkContext(conf)
    
    val textFile = "path/to/your/textfile.txt"
    val numbers = sc.textFile(textFile)
      .flatMap(line => line.replaceAll("[^\\d.]", " ").split("\\s+"))
      .filter(_.matches("\\d+")) // 只保留数字
      .map(_.toInt) // 转换为整型
      .reduce(_ + _) / sc.textFile(textFile).count() // 计算平均值
    
    println(s"Average: $numbers")
  }
}

3. 将文本行反转

import org.apache.spark.{SparkConf, SparkContext}

object ReverseLines {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Reverse Lines")
    val sc = new SparkContext(conf)
    
    val textFile = "path/to/your/textfile.txt"
    val reversed = sc.textFile(textFile)
      .map(line => line.reverse) // 反转每一行
    
    reversed.saveAsTextFile("path/to/output") // 保存结果，而非打印
  }
}

4. 统计每个单词的长度

import org.apache.spark.{SparkConf, SparkContext}

object WordLengthCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Word Length Count")
    val sc = new SparkContext(conf)
    
    val textFile = "path/to/your/textfile.txt"
    val lengths = sc.textFile(textFile)
      .flatMap(line => line.split("\\W+"))
      .map(word => (word, word.length)) // 计算每个单词的长度
      .reduceByKey(_ + _) // 这里实际是累加长度，但正确的做法应该是直接输出长度，上面这行是为了保持格式一致性，正确逻辑应为groupByKey后处理
    
    // 正确输出每个单词长度的示例：
    lengths.foreach { case (word, length) => println(s"$word: $length") }
  }
}

5. 统计文本文件中的行数

import org.apache.spark.{SparkConf, SparkContext}

object LineCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("Line Count")
    val sc = new SparkContext(conf)
    
    val textFile = "path/to/your/textfile.txt"
    val count = sc.textFile(textFile).count()
    
    println(s"Number of lines: $count")
  }
}

 试卷四

一、选择题 (每小题 2 分，共 20 分)

1. HBase 与传统关系数据库的主要区别在于：
   A. 数据类型
   B. 数据操作
   C. 存储模式
   D. 以上所有

2. HBase 使用哪个组件作为底层存储？
   A. MapReduce
   B. Hive
   C. HDFS
   D. ZooKeeper

3. 以下哪个命令可以查看 HBase 服务器的状态？
   A. help
   B. status
   C. whoami
   D. list_namespace

4. Scala 语言的特性不包括：
   A. 面向对象
   B. 函数式编程
   C. 并发性
   D. 面向过程

5. Scala 中的 List 和 Set 的区别在于：
   A. List 是有序的，Set 是无序的
   B. List 可以包含重复元素，Set 不能包含重复元素
   C. List 是不可变的，Set 是可变的
   D. 以上所有

6. Spark 生态系统中用于处理流数据的组件是：
   A. Spark Core
   B. Spark SQL
   C. Spark Streaming
   D. Spark MLlib

7. Spark 中的 RDD 是指：
   A. Resilient Distributed Dataset
   B. Relational Distributed Dataset
   C. Real-time Distributed Dataset
   D. Reliable Distributed Dataset

8. Spark 中的 Transformation 操作的特点是：
   A. 惰性计算
   B. 立即计算
   C. 产生新的RDD
   D. 以上 A 和 C

9. Spark SQL 中的 DataFrame 和 Dataset 的区别在于：
   A. DataFrame 基于 Row 对象，Dataset 基于特定类型的数据结构
   B. DataFrame 可以进行类型推断，Dataset 需要显式转换
   C. DataFrame 更灵活，Dataset 更简洁
   D. 以上 A 和 C

10. Spark Streaming 的基本理念是：
    A. 数据的价值随着时间的流逝而降低
    B. 数据应该被缓存起来进行批量处理
    C. 应该使用高延迟的处理引擎
    D. 以上所有

二、判断题 (每小题 2 分，共 20 分)

1. HBase 只能存储字符串类型的数据。（√）
2. HBase 可以轻松实现横向扩展。（√）
3. Scala 的匿名函数必须有函数名。（×）
4. Spark Core 是 Spark 生态系统的核心组件。（√）
5. Spark SQL 可以处理关系表和 RDD。（√）
6. Spark Streaming 只能处理实时数据流。（×）
7. Spark MLlib 是一个机器学习库。（√）
8. Spark GraphX 是一个分布式图处理框架。（√）
9. RDD 是一个可变的数据集。（×）
10. DataFrame 和 Dataset 都是 Spark 中用于表示数据集的抽象类型。（√）

三、简答题 (每小题 5 分，共 20 分)

1. 简述 HBase 与传统关系数据库在数据存储模式上的区别。
2. 简述 Spark 生态系统中各个组件的功能和作用。
3. 简述 Spark 中 RDD 的概念和创建方式。
4. 简述 Spark SQL 中 DataFrame 与 Dataset 的区别。

四、程序分析题 (第 1-5 小题各 6 分，第 6 题 10 分，共 40 分)

1.以下代码的作用是？

val rdd = sc.parallelize(Array(1, 2, 3, 4, 5))
val doubled = rdd.map(x => x * 2)

解释： 该代码使用 SparkContext 创建一个包含数字 1 到 5 的 RDD，然后使用 map 转换操作将每个元素乘以 2 并生成一个新的 RDD doubled，其中包含 2、4、6、8、10。

2.以下代码的作用是？

val df = sc.parallelize(List( ("zhang" , "18") , ("wang" , 17) , ("LI" , 20) )).toDF("name" , "age")
val filteredDF = df.filter($"age" > 18)

解释： 该代码使用 SparkContext 创建一个包含姓名和年龄信息的 DataFrame，然后使用 filter 操作筛选出年龄大于 18 的行，生成一个新的 DataFrame filteredDF。

3.以下代码的作用是？

val users = sc.parallelize(Array((3L,("rxin","student")), (7L,("jgonzal","postdoc")), (5L,("franklin","prof")), (2L,("istoica","prof"))))
val relationships = sc.parallelize(Array(Edge(3L,7L,"collab"), Edge(5L,3L,"advisor"), Edge(2L,5L,"colleague"), Edge(5L,7L,"pi")))
val userGraph = Graph(users, relationships)

解释： 该代码使用 SparkContext 创建两个 RDD，分别包含顶点信息和边信息，然后使用 Graph 函数将它们组合成一个属性图 userGraph。

4.以下代码的作用是？

val counts = userGraph.triplets.map(triplet => (triplet.srcId, triplet.dstId, triplet.attr)).count()

解释： 该代码使用 triplets 操作获取图中所有边，然后使用 map 操作将每条边的源顶点 ID、目标顶点 ID 和属性提取出来，最后使用 count 操作统计边的数量。

5.以下代码的作用是？

val connectedComponents = userGraph.connectedComponents().vertices

解释： 该代码使用 connectedComponents 操作计算图中所有连通分量，然后使用 vertices 操作获取每个顶点所属的连通分量 ID。

6.分析以下代码，并解释每个步骤的作用。

val lines = sc.textFile("file:/home/hadoop/student.txt")
val words = lines.flatMap(_.split("\\s+"))
val wordCounts = words.map((_, 1))
val reducedWordCounts = wordCounts.reduceByKey(_ + _)
reducedWordCounts.foreach(println)

解释： 该代码使用 SparkContext 从文件中读取文本数据，然后执行以下步骤：

• 读取文件： sc.textFile("file:/home/hadoop/student.txt") 从指定路径读取文本文件，并将其转换为 RDD，每个元素代表一行文本。
• 拆分单词： lines.flatMap(_.split("\\s+")) 使用 flatMap 操作将每一行文本拆分成多个单词，并生成一个新的 RDD，每个元素代表一个单词。
• 映射为键值对： words.map((_, 1)) 使用 map 操作将每个单词映射为一个键值对，其中键是单词本身，值为 1。
• 聚合计数： wordCounts.reduceByKey(_ + _) 使用 reduceByKey 操作对相同单词的键值对进行聚合，将对应的值相加，统计每个单词出现的次数。
• 打印结果： reducedWordCounts.foreach(println) 使用 foreach 操作遍历统计结果，并打印每个单词及其出现的次数。

试卷四参考答案

一、选择题 (每小题 2 分，共 20 分)

1. D. 以上所有
   解释：HBase 与传统关系型数据库在数据类型、数据操作、存储模式等方面都有显著区别。

2. C. HDFS
   解释：HBase 使用 HDFS (Hadoop Distributed File System) 作为底层存储，以提供高可靠的海量数据存储能力。

3. B. status
   解释：status 命令用于查看 HBase 服务器的状态，包括运行状态、版本信息、集群配置等。

4. D. 面向过程
   解释：Scala 是一种面向对象编程语言，它支持面向对象编程、函数式编程、并发编程等特性，但不支持面向过程编程。

5. D. 以上所有
   解释：List 和 Set 是 Scala 中两种常用的集合类型，它们在有序性、元素重复性和可变性方面存在差异。

6. C. Spark Streaming
   解释：Spark Streaming 是 Spark 生态系统中专门用于处理流数据的组件，它支持对连续数据流进行实时分析和处理。

7. A. Resilient Distributed Dataset
   解释：RDD 是 Resilient Distributed Dataset 的缩写，表示弹性分布式数据集，是 Spark 中用于表示分布式数据的核心抽象。

8. D. 以上 A 和 C
   解释：Transformation 操作是 Spark 中对 RDD 进行转换的操作，它不会立即执行，而是惰性计算，并且会生成新的 RDD。

9. D. 以上 A 和 C
   解释：DataFrame 基于 Row 对象，具有明确的 Schema，但需要在操作时进行类型转换；Dataset 基于特定类型的数据结构，可以更方便地进行类型推断，代码更简洁，类型安全。

10. A. 数据的价值随着时间的流逝而降低
    解释：Spark Streaming 的基本理念是实时处理数据，因为数据的价值随着时间的流逝而降低，需要及时进行分析和处理。

二、判断题 (每小题 2 分，共 20 分)

1. √
   解释：HBase 的基本数据类型是字节数组，用户需要自行编写代码解析数据。

2. √
   解释：HBase 采用分布式架构，可以轻松添加或删除节点来实现横向扩展。

3. ×
   解释：Scala 的匿名函数可以没有函数名，它们通常用于一些简单的、一次性的操作。

4. √
   解释：Spark Core 是 Spark 生态系统的核心组件，提供分布式计算的基础功能。

5. √
   解释：Spark SQL 可以通过 DataFrame 和 Dataset 来统一处理关系表和 RDD。

6. ×
   解释：Spark Streaming 也能处理批处理数据，但它的主要特点是实时处理流数据。

7. √
   解释：Spark MLlib 是 Spark 生态系统中的机器学习库，提供各种机器学习算法和工具。

8. √
   解释：Spark GraphX 是 Spark 生态系统中的图计算框架，用于处理和分析图数据。

9. ×
   解释：RDD 是一个只读的数据集，一旦创建就不能修改。

10. √
    解释：DataFrame 和 Dataset 都是 Spark 中用于表示数据集的抽象类型，但它们在数据结构和操作方式上有所不同。

三、简答题 (每小题 5 分，共 20 分)

1. HBase 与传统关系数据库在数据存储模式上的主要区别在于：

   • HBase 基于列存储，将数据按列族进行组织，每个列族存储在一个独立的文件中，可以降低 IO 开销，支持大量并发用户查询。
   • 传统关系数据库基于行存储，将数据按行（元组）进行组织，查询时需要扫描整行数据，效率较低。

2. Spark 生态系统中各个组件的功能和作用：

   • Spark Core: 提供分布式计算的核心功能，包括任务调度、内存管理、错误恢复和与存储系统交互等。
   • Spark SQL: 用于操作结构化数据的组件，支持 SQL 查询和 RDD 操作，可以统一处理关系表和 RDD。
   • Spark Streaming: 实时数据处理框架，支持对连续数据流进行实时分析和处理。
   • Spark MLlib: 可扩展的机器学习库，包含各种机器学习算法和工具。
   • Spark GraphX: 分布式图处理框架，支持图计算和图处理操作。

3. Spark 中 RDD 的概念：

   • RDD 是 Resilient Distributed Dataset 的缩写，表示弹性分布式数据集。
   • RDD 是一个只读的分区记录集合，是 Spark 对具体数据对象的一种抽象。
   • RDD 可以通过并行化程序中的数据集或从外部存储系统加载数据来创建。

4. Spark SQL 中 DataFrame 与 Dataset 的区别：

   • DataFrame 基于 Row 对象，类似于关系型数据库中的表，具有明确的 Schema，但需要在操作时进行类型转换。
   • Dataset 基于特定类型的数据结构，例如 Dataset[Student]，可以更方便地进行类型推断，无需显式转换，代码更简洁，类型安全。

四、程序分析题 (第 1-5 小题各 6 分，第 6 题 10 分，共 40 分)

1. 该代码使用 SparkContext 创建一个包含数字 1 到 5 的 RDD，然后使用 map 转换操作将每个元素乘以 2 并生成一个新的 RDD doubled，其中包含 2、4、6、8、10。

2. 该代码使用 SparkContext 创建一个包含姓名和年龄信息的 DataFrame，然后使用 filter 操作筛选出年龄大于 18 的行，生成一个新的 DataFrame filteredDF。

3. 该代码使用 SparkContext 创建两个 RDD，分别包含顶点信息和边信息，然后使用 Graph 函数将它们组合成一个属性图 userGraph。

4. 该代码使用 triplets 操作获取图中所有边，然后使用 map 操作将每条边的源顶点 ID、目标顶点 ID 和属性提取出来，最后使用 count 操作统计边的数量。

5. 该代码使用 connectedComponents 操作计算图中所有连通分量，然后使用 vertices 操作获取每个顶点所属的连通分量 ID。

6. 该代码使用 SparkContext 从文件中读取文本数据，然后执行以下步骤：

   • 读取文件：sc.textFile("file:/home/hadoop/student.txt") 从指定路径读取文本文件，并将其转换为 RDD，每个元素代表一行文本。
   • 拆分单词：lines.flatMap(_.split("\\s+")) 使用 flatMap 操作将每一行文本拆分成多个单词，并生成一个新的 RDD，每个元素代表一个单词。
   • 映射为键值对：words.map((_, 1)) 使用 map 操作将每个单词映射为一个键值对，其中键是单词本身，值为 1。
   • 聚合计数：wordCounts.reduceByKey(_ + _) 使用 reduceByKey 操作对相同单词的键值对进行聚合，将对应的值相加，统计每个单词出现的次数。

试卷五

一、选择题（每小题2分，共20分）

1. HBase的数据存储模式是基于什么的？
   A. 行存储
   B. 列存储
   C. 文档存储
   D. 键值对存储

2. 关系数据库与HBase在数据维护上的主要区别是什么？
   A. HBase不支持更新操作
   B. HBase每次更新都会创建数据的新版本
   C. 关系数据库不保留数据的历史版本
   D. HBase不自动维护数据的一致性

3. 在Scala中，哪项不是Scala编程基础的特性？
   A. 面向对象
   B. 函数式编程
   C. 自动垃圾回收
   D. 可以和Java混编

4. 下列哪个Spark组件主要用于处理结构化数据？
   A. Spark Core
   B. Spark SQL
   C. Spark Streaming
   D. Spark MLlib

5. RDD的转换操作的特点是什么？
   A. 立即执行
   B. 惰性执行
   C. 只能执行一次
   D. 不可逆

6. DataFrame与Dataset的主要区别之一是什么？
   A. DataFrame不支持类型安全
   B. Dataset不支持SQL-like查询
   C. DataFrame的性能总是优于Dataset
   D. Dataset在编译时提供类型安全检查

7. 在Spark Streaming中，处理数据的基本单位是什么？
   A. RDD
   B. Dataset
   C. DStream
   D. DataFrame

8. 创建HBase表的命令中，如何指定列族和版本数？
   A. create '表名', {NAME=>'列族名', VERSION=>版本数}
   B. create '表名', {COLUMN=>'列族名', COUNT=>版本数}
   C. create '表名', '列族名', VERSIONS=>版本数
   D. create '表名', '列族名', {VERSIONS=>版本数}

9. Scala中定义一个匿名函数将两个整数相加的正确语法是？
   A. val add = (x, y) => x + y
   B. function add(x, y) = x + y
   C. def add = (x, y) => x + y
   D. val add(x, y): Int = x + y

10. 在Spark中，哪种部署模式最适合快速测试代码？
    A. Local
    B. Standalone
    C. EC2
    D. YARN

二、判断题（每小题2分，共20分）

1. HBase利用HDFS作为存储，因此可以直接处理非结构化数据。
   [ ]

2. 在Scala中，所有的值都有一个类型，包括Unit类型，表示无返回值。
   [ ]

3. Spark SQL可以直接处理RDD，无需转换。
   [ ]

4. HBase的列族在创建表后不能修改。
   [ ]

5. 在Scala中，使用val声明的变量可以重新赋值。
   [ ]

6. Spark Streaming的最小处理时间间隔可以无限小。
   [ ]

7. 使用Spark的MLlib库进行机器学习时，可以直接处理DataFrame数据。
   [ ]

8. HBase的Shell命令put用于删除表中的数据。
   [ ]

9. Scala的模式匹配仅适用于case class，不适用于普通类。
   [ ]

10. 在Spark中，通过coalesce操作可以增加RDD的分区数。
    [ ]

三、简答题（每小题5分，共20分）

1. 解释HBase的列族概念及其重要性。

2. Scala中的函数式编程特性如何帮助提升代码的可读性和维护性？

3. 简述Spark Core在Spark生态系统中的作用。

4. 如何在HBase中使用Shell命令创建一个包含两个列族的表，并设置每个列族的版本数？

四、程序分析题（共40分）

1. （6分）分析以下Scala代码片段，该片段旨在创建一个Spark DataFrame来处理学生信息，请指出创建DataFrame的关键步骤并解释其作用。

   val list = List(("Alice", 20), ("Bob", 22))
   val df = spark.createDataFrame(list).toDF("Name", "Age")
   

2. （6分）给出一个简单的Spark程序，用于统计文本文件中每个单词的出现次数。分析其工作流程。

3. （6分）解释如何在HBase中使用Shell命令插入一行数据，包括行键、列族和时间戳的。

4. （6分）在Scala中，编写一个函数，使用匿名函数和高阶函数来计算一个整数列表的平均值。分析该函数如何利用函数式编程原则。

5. （6分）描述如何使用Spark SQL的DataFrame API来从一个包含多列的DataFrame中选择特定列，并对选定列应用过滤条件。

6. （10分）编写一个Spark程序片段，该程序使用Spark Streaming从一个网络数据源（如Twitter流）中读取数据，并统计每分钟出现频率最高的10个单词。请简要说明程序的主要步骤和使用的Spark Streaming关键API。

试卷五答案

一、选择题

1. B. 列存储 - 正确，HBase基于列族存储数据，不同于关系数据库的行存储模式。
2. B. HBase每次更新都会创建数据的新版本 - 正确，HBase的更新操作实际上是增加了一个新的版本，保留历史数据。
3. C. 自动垃圾回收 - 这个选项在题目中描述不准确，Scala确实有垃圾回收机制，但这不是其核心特性，正确答案应聚焦于Scala的面向对象、函数式、扩展性、并发和混编特性。
4. B. Spark SQL - 正确，Spark SQL是处理结构化数据的主要组件。
5. B. 惰性执行 - 正确，RDD的转换操作是惰性执行的，只有在执行行动操作时才会真正计算。
6. D. Dataset在编译时提供类型安全检查 - 正确，Dataset提供编译时类型检查，增强了代码的安全性。
7. C. DStream - 正确，DStream是Spark Streaming的基本数据结构，用于处理实时数据流。
8. D. create '表名', '列族名', VERSIONS=>版本数 - 正确，指定列族和版本数的正确格式。
9. A. val add = (x, y) => x + y - 正确，这是定义匿名函数的正确方式。
10. A. Local - 正确，Local模式是Spark进行快速测试和开发的理想选择。

二、判断题

1. 错 - HBase处理结构化数据，但利用列族存储，适合大规模数据。
2. 对 - Scala的不可变变量和函数式特性有助于提高代码的可读性和维护性。
3. 错 - Spark SQL需要将非结构化的数据转换为结构化数据（如DataFrame或Dataset）后处理。
4. 对 - HBase的列族一旦创建，列可以在运行时动态添加，但列族本身难以更改。
5. 错 - val声明的是不可变变量，一旦赋值就不能重新赋值。
6. 错 - Spark Streaming的最小处理间隔受限于批处理的最小时间。
7. 对 - Spark SQL可以直接处理DataFrame，支持SQL-like查询。
8. 错 - put命令用于插入数据，不是删除。
9. 错 - Scala的模式匹配可以应用于任何对象，包括普通类。
10. 错 - coalesce通常用于减少RDD的分区数，虽然也可以增加，但不如repartition直接。

三、简答题

1. HBase的列族概念及其重要性：
   列族是HBase数据模型的核心，它是一组列的集合，用于逻辑上组织相关数据。重要性在于它允许高效的数据存储和检索，列族内的列可以动态增加，且存储设置（如缓存、压缩）可以按列族进行，这极大优化了数据访问和存储效率。

2. Scala的函数式编程提升代码质量：
   函数式编程强调无副作用、纯函数和不可变数据，这使得代码更易于理解、测试和并行化。通过使用高阶函数，如map、filter、fold等，可以减少循环和状态变化，提高代码的简洁性和可重用性。

3. Spark Core作用：
   Spark Core提供了基础的计算模型，包括RDD（弹性分布式数据集）的抽象、任务调度、内存管理、错误恢复等，它是Spark所有高级功能（如Spark SQL、Spark Streaming、MLlib等）的基础。

4. 创建HBase表命令：
   使用如下命令创建表并设置列族版本数：

   create 'students', {NAME=>'personal', VERSIONS=>2}, {NAME=>'academic', VERSIONS=>2}
   

四、程序分析题​​​​​​​

1. 关键步骤及解释：

   • 创建数据列表：List(("Alice", 20), ("Bob", 22))，创建了一个包含学生名字和年龄的列表。
   • 创建DataFrame：spark.createDataFrame(list)，将列表转换成Spark的DataFrame，这是Spark处理结构化数据的核心结构。
   • 列名指定：.toDF("Name", "Age")，为DataFrame中的列指定有意义的名字，便于后续操作和理解。

2. 工作流程分析：

   • 读取文本：使用SparkContext的textFile方法加载文本文件。
   • 映射单词：通过flatMap将每一行文本分割成单词。
   • 形成键值对：map操作将每个单词映射为(key, value)对，key是单词，value通常是1。
   • 聚合计数：reduceByKey操作合并相同键的值，实现单词计数。

3. HBase Shell命令插入数据步骤：

   • 首先确保HBase shell已经启动。
   • 使用命令create 'students', 'info', 'scores'创建一个表，其中包含列族'info'和'scores'。
   • 插入数据的命令格式一般为：put '表名', '行键', '列族:列名', '值', '时间戳'。例如，插入一行数据：put 'students', '001', 'info:name', 'Alice', '202304011200'。这会在表'students'中，针对行键'001'，在列族'info'下添加一个名为'name'的列，值为'Alice'，并可指定时间戳。

4. 匿名函数和高阶函数计算平均值的Scala代码：

   def average(numbers: List[Int]): Double = {
     numbers.sum.toDouble / numbers.length
   }
   val nums = List(1, 2, 3, 4, 5)
   val avg = average(nums) // 使用高阶函数隐式（这里没有直接使用匿名函数，但sum可视为内部实现）
   

   分析： 这里虽然直接使用了sum和length，但体现了函数式编程中数据处理的链式和无副作用的特性。若用匿名函数，可以这样表示计算过程：

   val avg = nums.foldLeft(0)((sum, num) => sum + num) / nums.length
   

5. 选择特定列并应用过滤条件的Spark SQL示例：

   import org.apache.spark.sql.functions._
   val filteredDF = df.select("Name").where(col("Age") > 21)
   

   分析： 使用select函数选择列，where结合col函数应用过滤条件，展示了DataFrame API的强大和简洁性。

6. Spark Streaming程序片段分析：
   主要步骤：

   • 初始化Spark Streaming Context：val ssc = new StreamingContext(spark.sparkContext, Seconds(60))，设置批处理间隔为1分钟。
   • 创建DStream：通过ssc.socketTextStream("host", port)连接到数据源。
   • 数据预处理：将接收到的每行数据分割成单词。
   • 单词计数：使用flatMap, map, reduceByKey组合进行单词计数。
   • 排序并取前10：使用transform操作转换DStream，对结果进行排序并选取前10。
   • 显示结果：通过foreachRDD打印每批处理结果。
   • 启动流处理：ssc.start(); ssc.awaitTermination()开始处理并等待程序结束。

   关键API：socketTextStream用于接收数据，flatMap, map, reduceByKey用于数据处理，foreachRDD用于处理每批数据的结果输出。