计算时机
- 转换算子
转换算子是惰性执行的，这意味着在调用转换算子时，系统不会立即进行数据处理。这种惰性计算的方式可以让 Spark 对操作进行优化，例如合并多个转换操作，减少数据的传输和处理量。 - 行动算子
行动算子是立即执行的。当调用行动算子时，Spark 会根据之前的转换操作构建执行计划，并在集群上执行计算，最终将结果返回给驱动程序或者保存到外部存储。
返回值类型
- 转换算子
转换算子通常返回一个新的数据集（如RDD、DataFrame等），这个新的数据集是基于原始数据集经过转换操作得到的。 - 行动算子
行动算子的返回值类型取决于具体的算子。例如，count算子返回一个整数，表示数据集中元素的数量；collect算子返回一个包含数据集中所有元素的列表。
对数据的影响
- 转换算子
转换算子只是定义了数据的转换逻辑，不会改变原始数据集。每次调用转换算子都会生成一个新的数据集，原始数据集保持不变。 - 行动算子
行动算子会触发实际的计算，可能会对数据进行聚合、过滤等操作，最终得到一个具体的结果。这个结果可能是一个数值、一个列表或者保存到外部存储的文件。 -
1.map 算子
作用：对 RDD 中的每个元素应用给定的函数 f，将每个元素转换为另一个元素，最终返回一个新的 RDD。这个函数 f 接收一个输入类型为 T 的元素，返回一个类型为 U 的元素。
格式：def map[U: ClassTag](f: T => U): RDD[U]
示例代码
import org.apache.spark.{SparkConf, SparkContext} object MapExample { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("MapExample").setMaster("local[*]") val sc = new SparkContext(conf) val rdd = sc.parallelize(Seq(1, 2, 3, 4)) val newRdd = rdd.map(x => x * 2) newRdd.collect().foreach(println) sc.stop() } }2.filter 算子
作用：筛选出 RDD 中满足函数 f 条件（即 f 函数返回 true）的元素，返回一个新的 RDD，新 RDD 中的元素类型与原 RDD 相同。
格式：def filter(f: T => Boolean): RDD[T]
示例代码
import org.apache.spark.{SparkConf, SparkContext} object FilterExample { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("FilterExample").setMaster("local[*]") val sc = new SparkContext(conf) val rdd = sc.parallelize(Seq(1, 2, 3, 4)) val newRdd = rdd.filter(x => x % 2 == 0) newRdd.collect().foreach(println) sc.stop() }}3.flatMap算子
作用：对 RDD 中的每个元素应用函数 f，函数 f 返回一个可遍历的集合，然后将这些集合中的元素扁平化合并成一个新的 RDD。
格式：def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
示例代码
import org.apache.spark.{SparkConf, SparkContext} object FlatMapExample { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("FlatMapExample").setMaster("local[*]") val sc = new SparkContext(conf) val rdd = sc.parallelize(Seq("hello world", "spark is great")) val newRdd = rdd.flatMap(x => x.split(" ")) newRdd.collect().foreach(println) sc.stop() }}4.reduceByKey 算子
reduceByKey 是 Spark 中用于处理键值对（Key - Value）类型 RDD 的一个重要转换算子。它的核心作用是对具有相同键的所有值进行聚合操作，通过用户提供的聚合函数将这些值合并成一个结果，从而实现数据的归约和统计。例如统计每个键出现的次数、计算每个键对应值的总和、平均值等。
格式
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
参数说明：
func: (V, V) => V：这是一个二元函数，用于定义如何对相同键的值进行聚合。函数接收两个类型为 V 的值，返回一个类型为 V 的结果。例如，若要对相同键的值进行求和，func 可以是 (x, y) => x + y。
numPartitions: Int（可选）：指定结果 RDD 的分区数。如果不提供该参数，将使用默认的分区数。
以下是一个使用 reduceByKey 计算每个单词出现次数的示例：
import org.apache.spark.{SparkConf, SparkContext} object ReduceByKeyExample { def main(args: Array[String]): Unit = { // 创建 SparkConf 对象 val conf = new SparkConf().setAppName("ReduceByKeyExample").setMaster("local[*]") // 创建 SparkContext 对象 val sc = new SparkContext(conf) // 创建一个包含单词的 RDD val words = sc.parallelize(List("apple", "banana", "apple", "cherry", "banana", "apple")) // 将每个单词映射为 (单词, 1) 的键值对 val wordPairs = words.map(word => (word, 1)) // 使用 reduceByKey 计算每个单词的出现次数 val wordCounts = wordPairs.reduceByKey(_ + _) // 输出结果 wordCounts.collect().foreach(println) // 停止 SparkContext sc.stop() } }行动算子
1. collect算子
作用：用于将分布式存储在集群中各个节点上的 RDD 元素收集到驱动程序（Driver Program）中，并以数组的形式返回。这意味着该算子会触发 Spark 作业的执行，将之前的转换操作进行实际计算，并将结果汇总到驱动程序所在的节点。
格式：def collect(): Array[T]
参数说明：该算子没有参数。
返回值：返回一个包含 RDD 中所有元素的数组，数组元素的类型与 RDD 中元素的类型一致。
示例代码
object CollectExample { def main(args: Array[String]): Unit = { // 省略 ... // 创建一个包含整数的 RDD val numbers = sc.parallelize(1 to 10) // 使用 collect 算子将 RDD 中的元素收集到驱动程序 val collectedNumbers = numbers.collect() // 输出收集到的元素 collectedNumbers.foreach(println) // 停止 SparkContext sc.stop() }}2.reduce算子
作用：reduce 用于对 RDD 中的元素进行全局聚合操作，例如计算 RDD 中所有元素的总和、最大值、最小值等。在分布式计算环境中，reduce 会先在每个分区内进行局部聚合，然后将各个分区的结果进行全局聚合，最终得到一个单一的结果。
格式
def reduce(func: (T, T) => T): T
参数说明：
func: (T, T) => T：这是一个二元函数，用于定义如何对 RDD 中的元素进行聚合。函数接收两个类型为 T 的元素，返回一个类型为 T 的结果。例如，若要对 RDD 中的整数进行求和，func 可以是 (x, y) => x + y。
返回值：返回一个单一的值，其类型与 RDD 中元素的类型相同。
示例代码
以下是一个使用 reduce 计算 RDD 中所有整数之和的示例：
object ReduceExample { def main(args: Array[String]): Unit = { // 省略... // 创建一个包含整数的 RDD val numbers = sc.parallelize(1 to 10) // 使用 reduce 算子计算所有元素的总和 val sum = numbers.reduce(_ + _) // 输出结果 println(s"RDD 中所有元素的总和为: $sum") // 停止 SparkContext sc.stop() }}3.count算子
作用：count 是 Spark 中的一个行动算子，用于统计 RDD 中元素的数量。它会触发 Spark 作业的实际执行，对 RDD 中的所有元素进行计数，并将最终的计数结果返回给驱动程序。例如在进行数据验证、抽样或者评估数据处理任务的复杂度时，都可能需要知道 RDD 中元素的数量
格式
def count(): Long
参数说明：该算子没有参数。
返回值：返回一个 Long 类型的值，表示 RDD 中元素的数量。
4. 示例代码
import org.apache.spark.{SparkConf, SparkContext} object CountExample { def main(args: Array[String]): Unit = { // 创建 SparkConf 对象 val conf = new SparkConf().setAppName("CountExample").setMaster("local[*]") // 创建 SparkContext 对象 val sc = new SparkContext(conf) // 创建一个包含字符串的 RDD val words = sc.parallelize(List("apple", "banana", "cherry", "date")) // 使用 count 算子统计 RDD 中元素的数量 val count = words.count() // 输出结果 println(s"RDD 中元素的数量为: $count") // 停止 SparkContext sc.stop() }}4.foreach算子
作用：foreach 用于对 RDD 中的每个元素应用指定的函数。它主要用于执行一些副作用操作，比如将数据写入外部存储系统（如数据库、文件系统等），或者进行日志记录等。与其他转换算子不同，foreach 不会返回一个新的 RDD，而是直接对每个元素执行操作。
格式def foreach(f: T => Unit): Unit
参数说明：
f: T => Unit：这是一个函数，它接收一个类型为 T 的元素（T 为 RDD 中元素的类型），并对该元素执行相应的操作，但不返回任何值（返回类型为 Unit）。
返回值：该算子的返回类型为 Unit，即不返回任何有意义的值，它主要是为了执行副作用操作。
示例代码
object ForeachExample { def main(args: Array[String]): Unit = { // 创建一个包含整数的 RDD val numbers = sc.parallelize(1 to 5) // 使用 foreach 算子对每个元素应用打印操作 numbers.foreach(num => println(s"元素: $num")) // 停止 SparkContext sc.stop() } }