Spark核心编程—RDD算子(转换算子)

持续更新中

序号	算子名称	类型	函数说明
1	map	Value	将处理的数据逐条映射转换（类型或者值的转换）
2	mapPartition	Value	将待处理的数据以分区为单位发送到计算节点进行处理（可以进行任意处理，包括过滤数据）
3	mapPartitionWithIndex	Value	将待处理的数据以分区为单位发送到计算节点进行处理,并获得当前分区索引
4	flatMap	Value	将待处理的数据进行扁平化后再进行映射处理，也称之为扁平映射
5	glom	Value	将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
6	groupBy	Value	将数据根据指定的规则进行分组, 分区默认不变，数据重新组合，也称之为shuffle
7	filter	Value	将数据根据指定的规则进行筛选过滤，符合规则,保留，不符则丢弃
8	sample	Value	根据指定的规则从数据集中抽取数据
9	distinct	Value	将数据集中重复的数据去重
10	coalesce	Value	根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
11	repartition	Value	该操作内部其实执行的是 coalesce 操作，参数 shuffle 的默认值为 true
12	sortBy	Value	该操作用于排序数据，默认为升序排列
13	intersection	双Value	对源 RDD 和参数 RDD 求交集后返回一个新的 RDD
14	union	双Value	对源 RDD 和参数 RDD 求并集后返回一个新的 RDD
15	subtract	双Value	以一个 RDD 元素为主，去除两个 RDD 中重复元素，将其他元素保留下来。求差集
16	zip	双Value	将两个 RDD 中的元素，以键值对的形式进行合并
17	partitionBy	key-Value	将数据按照指定 Partitioner 重新进行分区
18	reduceByKey	key-Value	将数据按照相同的 Key 对 Value 进行聚合
19	groupByKey	key-Value	将数据根据 key 对 value 进行分组
20	aggregateByKey	key-Value	将数据根据不同的规则进行分区内计算和分区间计算
21	foldByKey	key-Value	当分区内计算规则和分区间计算规则相同时，aggregateByKey 就可以简化为 foldByKey
22	combineByKey	key-Value	对 key-value 型 rdd 进行聚集操作
23	sortByKey	key-Value	按照 key 进行排序
24	join	key-Value	返回一个相同 key 对应的所有元素连接在一起的(K,(V,W))的 RDD
25	leftOuterJoin	key-Value	类似于 SQL 语句的左外连接
26	cogroup	key-Value	在类型为(K,V)和(K,W)的 RDD 上调用，返回一个(K,(Iterable,Iterable))类型的 RDD

一、RDD转换算子

1、Spark基础编程中的RDD算子也成为RDD方法，包括两大类，一类是转换算子，另一类是行动算子。RDD转换算子主要对旧的RDD包装成新的RDD,实现功能的补充与封装。RDD行动算子主要是触发任务的调度与执行。

2、RDD 根据数据处理方式的不同将算子整体上分为 Value 类型、双 Value 类型和 Key-Value类型。

（ 一 ）Value类型

1、map

函数说明：将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

package Operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{
   SparkConf, SparkContext}
object Spark01_RDD_Operator_Transform {
   
  def main(args: Array[String]): Unit = {
   
    val sparkConf=new SparkConf().setAppName("Operator").setMaster("local[*]")
    val sc=new SparkContext(sparkConf)

    //TODO 算子-map
    val rdd: RDD[Int] = sc.makeRDD(List(1, 3, 6, 8), 2)
    val maprdd3=rdd.map( _*2 )
    maprdd3.collect().foreach(println)

    sc.stop()
  }
}
//输出 2 6 12 16

2、mapPartitions

函数说明： 将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

package Operator.transform
import org.apache.spark.rdd.RDD
import org.apache.spark.{
   SparkConf, SparkContext}

object Spark02_RDD_Operator_Transform_mapPartitions {
   
  def main(args: Array[String]): Unit = {
   
    val sparkConf=new SparkConf().setAppName("Operator").setMaster("local[*]")
    val sc=new SparkContext(sparkConf)


    //TODO 算子-mapPartitions
    val rdd: RDD[Int] = sc.makeRDD(List(1, 3, 6, 8), 2)
    //mapPartitions: 可以以分区为单位进行数据转换操作，会将整个分区的数据加载到内存中进行引用
    // 如果处理完的数据是不会被释放掉的，存在对象的引用。
    // 在内存较小，数据量较大的场合下，容易出现内存溢出

    val maprdd: RDD[Int] =rdd.mapPartitions(
    iter => {
   
      iter.map(_+2)
    })
    maprdd.collect().foreach(println)

    sc.stop()
  }
}
//输出 3 5 8 10

问题思考：map 和 mapPartitions的区别？

参考链接： http://t.csdn.cn/hq6bB

3、mapPartitionWithIndex

函数说明： 将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

package Operator.transform

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

object Spark03_RDD_Operator_Transform_mapPartitionsWithIndex {
   
  def main(args: Array[String]): Unit = {
   
    val sparkConf = new SparkConf().setAppName("Operator").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)


    //TODO 算子-mapPartitionsWithIndex
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 6, 8), 2) //后面的2代表分区数，从0开始，0:(1,2)   1:(6,8)

    /* 获取第二个数据分区的数据 */
    val mpirdd: RDD[Int] = rdd.mapPartitionsWithIndex(