Spark RDD算子

叶域2024-06-11 13:24

Spark RDD算子

转换算子（Transformation Operators）

类别 算子名称 简要介绍
映射类算子 [map](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 对RDD中的每个元素进行操作，返回一个新的RDD
[flatMap](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 类似于map，但每个输入元素可映射到0或多个输出元素
[mapPartitions](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 对RDD的每个分区中的元素进行操作，返回一个新的RDD
mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引
mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD
flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素
过滤类算子 [filter](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 过滤出满足条件的元素，返回一个新的RDD
[distinct](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 去除重复元素，返回一个新的RDD
分组类算子 [groupBy](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD
[groupByKey](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 对键值对RDD中的值进行分组，返回一个新的键值对RDD
[reduceByKey](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 对具有相同键的值进行合并，返回一个新的键值对RDD
[aggregateByKey](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD
[combineByKey](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 类似于aggregateByKey，但允许更灵活的聚合过程
[cogroup](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 对两个或多个键值对RDD进行分组，返回一个新的RDD
排序类算子 [sortByKey](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 根据键对键值对RDD进行排序，返回一个新的键值对RDD
[sortBy](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 根据指定的函数对RDD进行排序，返回一个新的RDD
repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD
连接类算子 [union](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 合并两个RDD，返回一个新的RDD
[intersection](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 计算两个RDD的交集，返回一个新的RDD
[subtract](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD
cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD
[join](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 根据键连接两个键值对RDD，返回一个新的键值对RDD
[leftOuterJoin](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 左外连接两个键值对RDD，返回一个新的键值对RDD
[rightOuterJoin](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 右外连接两个键值对RDD，返回一个新的键值对RDD
[fullOuterJoin](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 全外连接两个键值对RDD，返回一个新的键值对RDD
分区类算子 [sample](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 随机采样RDD中的元素，返回一个新的RDD
randomSplit 随机划分RDD中的元素，返回一个RDD数组
pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD
[coalesce](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 减少RDD的分区数，返回一个新的RDD
[repartition](#类别 算子名称 简要介绍 映射类算子 map 对RDD中的每个元素进行操作，返回一个新的RDD flatMap 类似于map，但每个输入元素可映射到0或多个输出元素 mapPartitions 对RDD的每个分区中的元素进行操作，返回一个新的RDD mapPartitionsWithIndex 类似于mapPartitions，但提供了分区索引 mapValues 对键值对RDD中的每个值进行操作，返回一个新的键值对RDD flatMapValues 对键值对RDD中的每个值进行操作，每个值可映射到0或多个输出元素 过滤类算子 filter 过滤出满足条件的元素，返回一个新的RDD distinct 去除重复元素，返回一个新的RDD 分组类算子 groupBy 根据指定的函数对RDD中的元素进行分组，返回一个新的RDD groupByKey 对键值对RDD中的值进行分组，返回一个新的键值对RDD reduceByKey 对具有相同键的值进行合并，返回一个新的键值对RDD aggregateByKey 使用指定的聚合函数和中间结果进行聚合，返回一个新的键值对RDD combineByKey 类似于aggregateByKey，但允许更灵活的聚合过程 cogroup 对两个或多个键值对RDD进行分组，返回一个新的RDD 排序类算子 sortByKey 根据键对键值对RDD进行排序，返回一个新的键值对RDD sortBy 根据指定的函数对RDD进行排序，返回一个新的RDD repartitionAndSortWithinPartitions 对RDD进行重新分区并在每个分区内排序，返回一个新的RDD 连接类算子 union 合并两个RDD，返回一个新的RDD intersection 计算两个RDD的交集，返回一个新的RDD subtract 从一个RDD中移除另一个RDD中的元素，返回一个新的RDD cartesian 计算两个RDD的笛卡尔积，返回一个新的RDD join 根据键连接两个键值对RDD，返回一个新的键值对RDD leftOuterJoin 左外连接两个键值对RDD，返回一个新的键值对RDD rightOuterJoin 右外连接两个键值对RDD，返回一个新的键值对RDD fullOuterJoin 全外连接两个键值对RDD，返回一个新的键值对RDD 分区类算子 sample 随机采样RDD中的元素，返回一个新的RDD randomSplit 随机划分RDD中的元素，返回一个RDD数组 pipe 将RDD的每个分区作为外部进程的输入，返回一个新的RDD coalesce 减少RDD的分区数，返回一个新的RDD repartition 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD) 增加或减少RDD的分区数，并进行数据洗牌，返回一个新的RDD
partitionBy 根据指定的分区器对键值对RDD进行分区，返回一个新的键值对RDD

行动算子（Action Operators）

类别 算子名称 简要介绍
聚合类算子 reduce 对RDD中的元素进行归约操作，返回一个结果
fold 类似于reduce，但带有初始值
aggregate 使用指定的聚合函数和中间结果对RDD进行聚合，返回一个结果
计数类算子 count 计算RDD中的元素数量，返回一个长整型结果
countByKey 计算每个键的出现次数，返回一个键值对Map
countByValue 计算每个值的出现次数，返回一个值对Map
收集类算子 collect 将RDD的所有元素收集到驱动程序，返回一个数组
collectAsMap 将键值对RDD的所有元素收集到驱动程序，返回一个Map
take 获取RDD的前n个元素，返回一个列表
takeSample 随机获取RDD的样本，返回一个列表
takeOrdered 获取排序后的RDD的前n个元素，返回一个列表
获取类算子 first 获取RDD的第一个元素，返回一个元素
top 获取排序后的RDD的前n个元素，返回一个列表
遍历类算子 foreach 对RDD中的每个元素执行操作，不返回结果
foreachPartition 对RDD的每个分区中的元素执行操作，不返回结果
保存类算子 saveAsTextFile 将RDD保存到文本文件中
saveAsSequenceFile 将RDD保存为序列文件
saveAsObjectFile 将RDD保存为对象文件
saveAsHadoopFile 将RDD保存为Hadoop文件
saveAsNewAPIHadoopFile 将RDD保存为新API的Hadoop文件
saveAsHadoopDataset 将RDD保存为Hadoop数据集

一、转换算子（Transformation Operators）

1、逐条处理

scala 复制代码 
// val rdd2: RDD[U] = rdd.map(f: T=>U)
val data = Array("word1", "word2", "word3")
// 将单词 word 映射为元组 (word, 1)
val rdd: RDD[(String, Int)] = sc.parallelize(data).map(word => (word, 1))

2、扁平化处理

scala 复制代码 
val sentences = List("Hello world", "Apache Spark is awesome", "FlatMap example")
// 将一个句子拆分为多个单词，1=>多，并将所有的结果元素合并为一个新的 RDD
val rdd: RDD[String] = sc.parallelize(sentences).flatMap(word => word.split(" "))

3、分区内逐行处理

【✔ 】：以分区为单位(分区不变)逐行处理数据

map VS mapPartitions

1、数量：前者一进一出IO数量一致，后者多进多出IO数量不一定一致

2、性能：前者多分区逐条处理，后者各分区并行逐条处理更佳，常时间占用内存易导致OOM，内存小不推荐

3、类型：两者入口和出口类型都必须一致，后者进出都必须是迭代器

scala 复制代码 
// 在同一个 mapPartitions 操作中进行过滤和转换操作，可以减少对数据的多次遍历，从而提高性能。
mapParitions( 
// ≈ 子查询
it.filter(...) // 谓词下缀
)

// 分别使用 mapPartitions 和 filter 进行转换和过滤操作，增加计算开销。
mapParitions(...)
fielter(...)     // where
scala 复制代码 
// 一个包含整数的 RDD，过滤出偶数并将其乘以 2。
val data = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val rdd: RDD[Int] = sc.parallelize(data, 3) // 创建3个分区
// 使用 mapPartitions 进行过滤和转换
val resultRDD: RDD[Int] = rdd.mapPartitions { it =>
    val filtered = it.filter(_ % 2 == 0) // 过滤偶数
    filtered.map(_ * 2) // 将每个偶数乘以 2
}

// 【分区内逐行处理】：以分区为单位(分区不变)逐行处理数据，并追加分区编号
val rdd2: RDD[U] = rdd.mapPartitionsWithIndex(f:(Int,Iterator[T])=>Iterator[U][,preservePar:Boolean])
// mapPartitionsWithIndex 功能同mapPartitions，区别在于追加了分区编号，一般用于去掉表头和分析调试

4、转内存数组

分区的数据转为同类型的内存数组，分区不变 rdd:RDD[T]

scala 复制代码 
// val rdd2: RDD[Array[T]] = rdd.glom();
// 创建一个包含 1 到 100 的整数 RDD，分为 5 个分区
val rdd = sc.parallelize(1 to 100, 5)
// 使用 glom() 将每个分区的元素合并成一个数组
val glommedRDD = rdd.glom()
// 输出每个分区合并后的数组
glommedRDD.collect().foreach { partition =>
    println("Partition contains: " + partition.mkString(", "))
}

5、数据过滤

过滤规则 f:T=>Boolean，保留满足条件数据，分区不变，不推荐用

【数据可能倾斜】某些分区的数据量远远超过了其他分区，造成数据分布不均匀

scala 复制代码 
// val rdd2: RDD[T] = rdd.filter(f:T=>Boolean)
// 创建一个包含 1 到 10 的整数 RDD
val rdd = sc.parallelize(1 to 10)
// 使用 filter 过滤出偶数
val evenRDD = rdd.filter(num => num % 2 == 0)

6、数据分组

同键同组同区，同区可多组；打乱shuffle，按f:T=>K规则，分区不变，【数据可能倾斜】

scala 复制代码 
// val rdd2: RDD[(K,Iterable[T])] = rdd.groupBy(f:T=>K)
// val rdd2: RDD[(K,Iterable[T])] = rdd.groupBy(f:T=>K, partioner:Partitioner)
// val rdd2: RDD[(K,Iterable[T])] = rdd.groupBy(f:T=>K, numPartitions:Int)

// 定义一个自定义分区器，根据奇偶数进行分区
class OddEvenPartitioner(numPartitions: Int) extends Partitioner {
    override def numPartitions: Int = numPartitions
    override def getPartition(key: Any): Int = {
        val k = key.toString
        if (k == "even") 0 else 1
    }
}	
// 创建一个包含 1 到 10 的整数 RDD
val rdd = sc.parallelize(1 to 10)
// 使用 groupBy 方法，根据奇偶数进行分组
val groupedRDD = rdd.groupBy(num => if (num % 2 == 0) "even" else "odd", new OddEvenPartitioner(2))

7、数据抽样

函数名：sample

参数：
withReplacement:Boolean 是否有放回抽样
fraction:Double 抽样率
seed:Long 随机种子，默认为当前时间戳(一般缺省)

无放回抽样: sample(false, 0.4) => 抽样40%的数据，40条左右

有放回抽样: sample(true, 0.4) => 每条数据被抽取的概率为40% (可能有重复的元素)

scala 复制代码 
// val rdd2: RDD[T] = rdd.sample(withReplacement:Boolean, fraction:Double, seed:Long)
// 创建一个包含 1 到 10 的整数 RDD
val rdd = sc.parallelize(1 to 10)
// 使用 sample 方法，从 RDD 中有放回随机抽样抽中每个数概率为0.9 
val sampledRDD = rdd.sample(withReplacement = true, fraction = 0.9)

8、数据去重

采用该方法去重，数据规模比较大的情况下，数据压力比较大，因为数据需要在不同的分区间比较

一般采用分组的方式，将去重字段作为分组字段，在不同的分区内并行去重

scala 复制代码 
val rdd2: RDD[T] = rdd.distinct()
// numPartitions: Int 设定去重后的分区数
// 隐式参数 order: Ordering[T] 用于指定元素类型 T 的排序方式，以便在对元素进行去重时进行比较。
val rdd2: RDD[T] = rdd.distinct(numPartitions: Int)(implicit order: Ording[T] = null)

9、数据排序

处理数据f:T=>K，升降序asc: Boolean，分区数numPartitions:Int

默认排序前后分区一致，【有shuffle】，除非重新设定 numPartitions

全局排序，多分区间交换数据，效率较低。优化见 PairRDD

若：K为基本类型，则无需提供第二参数列表中的隐式参数 ord: Ordering[K]

若：K为自定义类型，则必须提供第二参数

scala 复制代码 
case class Student(stu_id: Int, stu_name: String, stu_class: String)
val stuData = Seq(
    Student(1, "李明", "ccc"),
    Student(2, "小刚", "bbb"),
    Student(3, "小红", "aaa"),
    Student(4, "张三", "aaa")
)

sortBy

scala 复制代码 
// val rdd: RDD[T] = rdd.sortBy(f:T=>K,asc:Boolean,numPartitions:Int)(implicit ord: Ordering[K], ctag: ClassTag[K])

val rdd = sc.parallelize(stuData)
// 使用 sortBy 方法对 RDD 按照 stu_class 进行排序，升序，指定分区数为 2
val sortedRdd: RDD[Student] = rdd.sortBy(stu => stu.stu_class, ascending = true, 2)

// 按照班级升序排序，如果班级相同则按照学生 ID 降序
val sortedRdd: RDD[Student] = rdd.sortBy(s => s, ascending = true, numPartitions = 2)(
    Ordering.by(s => (s.stu_class, -s.stu_id)),
    ClassTag(classOf[Student])    // 显式地传递了 ClassTag 参数 ClassTag(classOf[Student])，以确保在运行时能获取 Student 类型信息。
)

sortByKey

scala 复制代码 
//  按照班级升序排序，如果班级相同则按照学生 ID 降序
val rdd = sc.parallelize(stuData)
// 将 RDD 转换为键值对 RDD，其中键是 (stu_class, -stu_id)
val pairRDD: RDD[((String, Int), Student)] = rdd.map(student => ((student.stu_class, -student.stu_id), student))
// 使用 sortByKey 方法对键进行排序
val sortedPairRDD: RDD[((String, Int), Student)] = pairRDD.sortByKey()
// 取出排序后的 Student 对象
val sortedRDD: RDD[Student] = sortedPairRDD.map(_._2)

10、交并补差

多个类型 RDD[T]：纵向

交并差操作：数据类型一致，根据元素 equals 认定是否相同

【自定义类型】：必须重写 equals 方法，因为默认等值判断 == 判断地址

拉链操作：要求分区数和分区内的数据量一致

scala 复制代码 
val rdd1: RDD[Int] = sc.makeRDD(Seq(1, 3, 4, 6, 4, 3, 33, 31))
val rdd2: RDD[Int] = sc.makeRDD(Seq(2, 2, 4, 5, 1, 22, 3, 1))
// 【求交集】：重载可重设分区数numPartitions: Int，或定义分区规则par: Partitioner[T]
val rdd3: RDD[T] = rdd1.intersection(rdd2:RDD[T])
val rdd3: RDD[T] = rdd1.intersection(rdd2:RDD[T], numPartitions:Int)
val rdd3: RDD[T] = rdd1.intersection(rdd2:RDD[T], par:Partitioner[T])
// 【求并集】：不去重
val rdd3: RDD[T] = rdd1.union(rdd2:RDD[T])
// 【求差集】：重载可重设分区数numPartitions:Int，或定义分区规则par:Partitioner[T]
val rdd3: RDD[T] = rdd1.subtract(rdd2:RDD[T])
val rdd3: RDD[T] = rdd1.subtract(rdd2:RDD[T], numPartitions:Int)
val rdd3: RDD[T] = rdd1.subtract(rdd2:RDD[T], par:Partitioner[T])

11、拉链操作

scala 复制代码 
val rdd1: RDD[Int] = sc.makeRDD(Seq(1, 3, 4, 6, 4, 3, 33, 31))
val rdd2: RDD[Int] = sc.makeRDD(Seq(2, 2, 4, 5, 1, 22, 3, 1))

val rdd2: RDD[(T,U)] = rdd1.zip(rdd2:RDD[U])
val rdd2: RDD[(T,Long)] = rdd1.zipWithIndex()
val rdd2: RDD[(T,Long)] = rdd1.zipWithUniqueId()
// 有三个重载：1+1，1+2，1+3
val rdd2: RDD[V]=rdd.zipPartitions(rddA:RDD[A])(f:(Iterator[T],Iterator[A])=>Iterator[V])
val rdd2: RDD[V]=rdd.zipPartitions(rddA:RDD[A],preserveParitioning:Boolean)(f:(Iterator[T],Iterator[A])=>Iterator[V])

12、键值映射类算子

map

scala 复制代码 
case class Student(stu_id: Int, stu_name: String, stu_class: String)
val stuData = Seq(
    Student(1, "李明", "ccc"),
    Student(2, "小刚", "bbb"),
    Student(3, "小红", "aaa"),
    Student(4, "张三", "aaa")
)
val rdd = sc.parallelize(stuData)

// 使用 map 对 RDD 中的每个 Student 对象的 stu_id 增加 1
val resultRdd1 = rdd.map(stu => stu.copy(stu_id = stu.stu_id + 1))

// Student 对象转换为一个包含 (stu_id, stu_name) 元组的 RDD
val resultRdd2 = rdd.map(stu => (stu.stu_id, stu.stu_name))

mapPartitions

scala 复制代码 
val rdd = sc.parallelize(Seq(1, 2, 3, 4, 5, 6), numSlices = 2)
val resultRDD = rdd.mapPartitions(iter => {
  // 对每个分区的元素求和
  val sum = iter.sum
  // 返回求和结果作为新的分区
  Iterator(sum)
})
resultRDD.collect().foreach(println)	// 输出为6 15

13、键值分组聚合类

reduceByKey

scala 复制代码 
// reduceByKey + foldByKey + aggregateByKey 都调用 combineByKeyClassTag
// 【按键聚合值】: combiner和reduce的值类型相同，计算规则相同
// group by + combiner + reduce
val pairRdd2:RDD[(K,V)] = pairRdd.reduceByKey(f:(V,V)=>V)
val pairRdd2:RDD[(K,V)] = pairRdd.reduceByKey(f:(V,V)=>V, numPartitions:Int)
val pairRdd2:RDD[(K,V)] = pairRdd.reduceByKey(partitioner:Partitioner, f:(V,V)=>V)

val scoresRDD = sc.parallelize(Seq(
    ("Alice", 80),
    ("Bob", 90),
    ("Alice", 85),
    ("Bob", 95),
    ("Alice", 75)
))
val totalScoresRDD = scoresRDD.reduceByKey((score1, score2) => score1 + score2)
// 简写 val totalScoresRDD = scoresRDD.reduceByKey(_+_)
totalScoresRDD.collect().foreach(println)	// 输出(Alice,240) (Bob,185)

foldByKey

scala 复制代码 
// 【按键聚合值】: combiner和reduce的值类型相同，计算规则相同，带初值
val pairRdd2:RDD[(K,V)] = pairRdd.foldByKey(initV:V)(inParOp:(V,V)=>V)
val pairRdd2:RDD[(K,V)] = pairRdd.foldByKey(initV:V,numPartitions:Int)(inParOp:(V,V)=>V)
val pairRdd2:RDD[(K,V)] = pairRdd.foldByKey(initV:V,partitioner:Partitioner)(inParOp:(V,V)=>V)
// 数据同上 reduceByKey
val initialScores = 0
val totalScoresRDD = scoresRDD.foldByKey(initialScores)((score1, score2) => score1 + score2)

aggregateByKey

scala 复制代码 
// 与 reduceByKey 和 foldByKey 不同，aggregateByKey 允许指定一个初始值和两个聚合函数，可以对每个键的值进行更复杂的聚合操作。
// 【✔ 按键分别执行分区内和分区间计算】: combiner和reduce的值类型可不同，计算规则可不同
val pairRdd2:RDD[(K,U)] = pairRdd.aggregateByKey(initV:U)(inParOp:(U,V)=>U,betParOp:(U,U)=>U)
val pairRdd2:RDD[(K,U)] = pairRdd.aggregateByKey(initV:U,numPartitions:Int)(inParOp:(U,V)=>U,betParOp:(U,U)=>U)
val pairRdd2:RDD[(K,U)] = pairRdd.aggregateByKey(initV:U,partitioner:Partitioner)(inParOp:(U,V)=>U,betParOp:(U,U)=>U)
val rddPair2: RDD[(String, Float)] = rddPair.aggregateByKey(0.0f)(_+_,_+_)

val resultRDD = pairRdd.aggregateByKey(zeroValue)(
  (acc, value) => {
    // 对每个分区中的值进行聚合操作
    // 初始值为 zeroValue
    // 返回值将作为每个分区聚合的结果
    // 这个函数在每个分区内执行
    // acc 是聚合的累加器，value 是当前处理的值
    // 返回一个新的累加器
  },
  (acc1, acc2) => {
    // 对多个分区的聚合结果进行合并操作
    // acc1 和 acc2 是两个分区的聚合结果
    // 返回合并后的结果
  }
)
scala 复制代码 
val scoresRDD = sc.parallelize(Seq(
  ("Alice", 80),
  ("Bob", 90),
  ("Alice", 85),
  ("Bob", 95),
  ("Alice", 75)
))
val zeroValue = (0, 0) // 初始值为元组 (sum, count)
val resultRDD = scoresRDD.aggregateByKey(zeroValue)(
  (acc, score) => {
    // 分区内聚合函数，计算每个学生的总成绩和数量
    (acc._1 + score, acc._2 + 1)
  },
  (acc1, acc2) => {
    // 分区间聚合函数，合并每个学生的总成绩和数量
    (acc1._1 + acc2._1, acc1._2 + acc2._2)
  }
)
// 每个学生的总成绩和数量
resultRDD.foreach(println)	// (Alice,(240,3)) (Bob,(185,2))

combineByKey

scala 复制代码 
// 【按键分别执行分区内和分区间计算】: combiner和reduce的值类型可不同，计算规则可不同
val pairRdd2:RDD[(K,U)] = pairRdd.combineByKey(initV:V=>U,inParOp:(U,V)=>U,betParOp:(U,U)=>U)
val pairRdd2:RDD[(K,U)] = pairRdd.combineByKey(initV:V=>U,inParOp:(U,V)=>U,betParOp:(U,U)=>U,numPartitions:Int)
val pairRdd2:RDD[(K,U)] = pairRdd.combineByKey(initV:V=>U,inParOp:(U,V)=>U,betParOp:(U,U)=>U,partitioner:Partitioner,mapSideCombine:Boolean,serializer:Serializer)

val resultRDD = pairRDD.combineByKey(
  (value) => {
    // 创建组合器函数，用于将每个值转换为另一种形式（通常是一个累加器或缓冲区）
    // 返回值将作为每个键的第一个值的处理结果
  },
  (acc, value) => {
    // 合并值函数，用于将每个值与累加器或缓冲区进行合并
    // 返回值将作为每个键的聚合结果
  },
  (acc1, acc2) => {
    // 合并累加器函数，用于合并两个累加器或缓冲区
    // 返回值将作为多个分区的聚合结果
  }
)
scala 复制代码 
val scoresRDD = sc.parallelize(Seq(
  ("Alice", 80),
  ("Bob", 90),
  ("Alice", 85),
  ("Bob", 95),
  ("Alice", 75)
))

val resultRDD = scoresRDD.combineByKey(
  (score) => (score, 1), // 创建组合器，初始值为 (成绩, 1)，表示总成绩和数量
  (acc, score) => (acc._1 + score, acc._2 + 1), // 合并值，累加总成绩和数量
  (acc1, acc2) => (acc1._1 + acc2._1, acc1._2 + acc2._2) // 合并累加器，合并总成绩和数量
)

// 计算平均成绩
val avgScoresRDD = resultRDD.mapValues(sumCount => sumCount._1.toDouble / sumCount._2)

avgScoresRDD.collect().foreach(println)

groupByKey

scala 复制代码 
// groupByKey 会将具有相同键的元素分组在一起，但是这个操作可能会导致数据倾斜，因为它会将所有具有相同键的元素放在同一个分区中。
// 【✔ 按键分组】
val pairRdd2: RDD[(K, Iterable[V])] = pairRdd.groupByKey()
val pairRdd2: RDD[(K, Iterable[V])] = pairRdd.groupByKey(numPartitions:Int)
val pairRdd2: RDD[(K, Iterable[V])] = pairRdd.groupByKey(partitioner:Partitioner)

val scoresRDD = sc.parallelize(Seq(
  ("Alice", 80),
  ("Bob", 90),
  ("Alice", 85),
  ("Bob", 95),
  ("Alice", 75)
))

val groupedRDD = scoresRDD.groupByKey()

groupedRDD.collect().foreach { case (name, scores) =>
  println(s"$name: ${scores.mkString(", ")}")
}

14、关联聚合

groupWith

scala 复制代码 
// groupWith 对两个 RDD 中具有相同键的元素进行分组，返回一个新的 RDD，其中每个键对应的值是一个包含两个 RDD 中相同键的元素组成的元组。
// 【多数据集分组】：1VN 同键同组，不同RDD值进入TupleN的不同Iterable
-------------------------------------------------------------------------------
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1])] = pairRdd.groupWith(otherA: RDD[(K,V1)])
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1],Iterable[V2])] = pairRdd.groupWith(otherA: RDD[(K,V1)],otherB: RDD[(K,V2)])
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1],Iterable[V2],Iterable[V3])] = pairRdd.groupWith(otherA: RDD[(K,V1)],otherB: RDD[(K,V2)],otherC: RDD[(K,V3)])
                   
val scoresRDD1 = sc.parallelize(Seq(
  ("Alice", 80),
  ("Bob", 90),
  ("Alice", 85),
  ("Bob", 95),
  ("Alice", 75)
))

val scoresRDD2 = sc.parallelize(Seq(
  ("Alice", "Good"),
  ("Bob", "Excellent"),
  ("Alice", "Good"),
  ("Bob", "Excellent"),
  ("Alice", "Good")
))

val groupedRDD = scoresRDD1.groupWith(scoresRDD2)

groupedRDD.collect().foreach { case (name, (scores1, scores2)) =>
  println(s"$name: (${scores1.mkString(", ")}) | (${scores2.mkString(", ")})")
}

cogroup

scala 复制代码 
// 重载 1+1 1+2 1+3，追加再分区操作
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1])] = pairRdd.cogroup(otherA: RDD[(K,V1)])
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1])] = pairRdd.cogroup(otherA: RDD[(K,V1)],numPartitions:Int)
val pairRdd2: RDD[(K, (Iterable[V],Iterable[V1])] = pairRdd.cogroup(otherA: RDD[(K,V1)],partitioner:Partitioner)
// 示例同groupWith，两者区别：cogroup可对分组后的元素进行更复杂的操作，如在分组后对每个键的值进行聚合计算。

15、关联操作

【关联操作】：1V1

横向，根据键做关联

重载：numPartitions:Int 或 partitioner:Partitioner

scala 复制代码 
val pairRdd: RDD[(K, (V, V1))] = pairRdd1.join(pairRdd3:RDD[(K,V1)])
val pairRdd: RDD[(K, (V, Option[V1]))] = pairRdd1.leftOuterJoin(pairRdd3:RDD[(K,V1)])
val pairRdd: RDD[(K, (Option[V]), V1)] = pairRdd1.rightOuterJoin(pairRdd3:RDD[(K,V1)])
val pairRdd: RDD[(K, (Option[V]), Option[V1])] = pairRdd1.fullOuterJoin( pairRdd3:RDD[(K,V1)])

// 创建两个 RDD
val rdd1 = sc.parallelize(Seq(
  (1, "Alice"),
  (2, "Bob"),
  (3, "Charlie")
))
val rdd2 = sc.parallelize(Seq(
  (1, 25),
  (3, 30),
  (4, 35)
))
// join：内连接
val innerJoinRDD = rdd1.join(rdd2)
// leftOuterJoin：左外连接
val leftJoinRDD = rdd1.leftOuterJoin(rdd2)
// rightOuterJoin：右外连接
val rightJoinRDD = rdd1.rightOuterJoin(rdd2)
// fullOuterJoin：全外连接
val fullOuterJoinRDD = rdd1.fullOuterJoin(rdd2)

二、行动算子（Action Operators）

【返回】所有元素分别在分区间和分区内执行【聚集】操作的结果

reduce & fold 分区内和分区间执行相同操作，且类型与元素类型一致

aggregate 分区内和分区间执行不同操作，且类型与元素类型不一致

scala 复制代码 
val rst:T = rdd.reduce(f:(T,T)=>T)
val rst:T = rdd.fold(init:T)(f:(T,T)=>T)
val rst:U = rdd.aggregate(init:U)(f:(U,T)=>U,f:(U,T)=>U)
scala 复制代码 
val array:Array[T] = rdd.collect()	// 返回包含数据集中所有元素的数组

val rst:Long = rdd.count()	// 返回数据集中元素数量

val rst:Map[K,Long] = pairRdd.countByKey()	// 返回一个包含键值对的 Map，其中键是 RDD 中的键，值是对应键出现的次数。

val rst:T = rdd.max()	// 返回数据集中最大值

val rst:T = rdd.min()	// 返回数据集中最小值

val rst:T = rdd.first()	// 返回数据集中的第一个元素

val array:Array[T] = rdd.take(num:Int)	// 返回数据集中的前 num 个元素

val array:Array[T] = rdd.takeOrdered(num:Int)(implicit ord:Ordering[T])	// 返回排序后数据集中的前 num 个元素

rdd.foreach(f:T=>Unit)	// 遍历迭代
rdd.foreachPartition(f:Iterable[T]=>Unit) // 写数据库操作首选

持久化至文本文件，重载追加压缩功能

scala 复制代码 
import org.apache.hadoop.io.compress.{BZip2Codec, SnappyCodec}
import io.airlift.compress.lzo.LzopCodec
rdd.saveAsTextFile("out_path",classOf[BZip2Codec])
scala 复制代码 
rdd.saveAsTextFile(path:String)
rdd.saveAsTextFile(path:String,codec: Class[_ <: CompressionCodec])
rdd.saveAsObjectFile(path:String)

三、Spark RDD 并行度控制

默认的并行度：200

分区数的体现方式：

  • 分区数 numPartitions | numSlices: Int

    • 示例：val rdd = sc.parallelize(data, numPartitions = 5)

    • 分区逻辑

      scala 复制代码 
      partitionIndex = fieldName.hashCode() % numPartitions

    • 扩展随机字段 ：0 ~ numPartitions

  • 分区器 partitioner: Partitioner (针对键值对 RDD)

    • 默认的分区器 ：HashPartitioner
再分区算子

用于对数据进行重新分配。

  • coalesce ：coalesce(numPartitions: Int, shuffle: Boolean)
    • 用于减少分区数，通常在不需要洗牌时使用。
    • 示例：val coalescedRDD = rdd.coalesce(2, shuffle = false)
  • repartition ：repartition(numPartitions: Int)
    • 等同于 coalesce(numPartitions, true)，用于增加或减少分区数，并进行数据洗牌。
    • 示例：val repartitionedRDD = rdd.repartition(4)
相关推荐
panpantt32130 分钟前
【参会邀请】第二届大数据与数据挖掘国际会议（BDDM 2024）邀您相聚江城！
大数据·人工智能·数据挖掘
青云交36 分钟前
大数据新视界 -- 大数据大厂之 Impala 性能优化：跨数据中心环境下的挑战与对策（上）（27 / 30）
大数据·性能优化·impala·案例分析·代码示例·跨数据中心·挑战对策
soso19681 小时前
DataWorks快速入门
大数据·数据仓库·信息可视化
The_Ticker1 小时前
CFD平台如何接入实时行情源
java·大数据·数据库·人工智能·算法·区块链·软件工程
java1234_小锋1 小时前
Elasticsearch中的节点（比如共20个），其中的10个选了一个master，另外10个选了另一个master，怎么办？
大数据·elasticsearch·jenkins
Elastic 中国社区官方博客1 小时前
Elasticsearch 开放推理 API 增加了对 IBM watsonx.ai Slate 嵌入模型的支持
大数据·数据库·人工智能·elasticsearch·搜索引擎·ai·全文检索
我的运维人生1 小时前
Elasticsearch实战应用：构建高效搜索与分析平台
大数据·elasticsearch·jenkins·运维开发·技术共享
大数据编程之光2 小时前
Flink Standalone集群模式安装部署全攻略
java·大数据·开发语言·面试·flink
B站计算机毕业设计超人2 小时前
计算机毕业设计SparkStreaming+Kafka旅游推荐系统 旅游景点客流量预测 旅游可视化 旅游大数据 Hive数据仓库 机器学习 深度学习
大数据·数据仓库·hadoop·python·kafka·课程设计·数据可视化
在下不上天3 小时前
Flume日志采集系统的部署,实现flume负载均衡，flume故障恢复
大数据·开发语言·python
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作