尚硅谷大数据Spark之RDD转换算子学习笔记及面试题

1. Spark 算子从功能上可以分为以下两类:

1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。

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

2）Action 行动算子：这类算子会触发 SparkContext 提交 Job 作业。

Action 算子会触发 Spark 提交作业（Job），并将数据输出 Spark系统。

2. Value型Transformation算子

map	mapPartitions	mapPartitionsWithIndex	flatMap
glom	groupBy	filter	sample
distinct	coalesce	repartition	sortBy

面试题：请列举Spark的transformation算子(不少于8个)，并简述功能(重点)
1）map (func)：返回一个新的 RDD，该 RDD 由每一个输入元素经过func 函数转换后组成.
2）mapPartitions(func)：类似于 map，但独立地在 RDD 的每一个分片上运行，因此在类型为 T 的RDD上运行时，func 的函数类型必须是 Iterator[T] => Iterator[U]。假设有N个元素，有M个分区，那么map的函数的将被调用N次,而 mapPartitions 被调用M 次,一个函数一次处理所有分区。
3）reduceByKey（func，[numTask]）：在一个(K,V)的 RDD 上调用，返回一个(K,V)的RDD，使用定的 reduce 函数，将相同key 的值聚合到一起，reduce 任务的个数可以通过第二个可选的参数来设置。
4）aggregateByKey (zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U: 在kv 对的 RDD 中，，按 key 将value 进行分组合并，合并时，将每个 value 和初始值作为 seq 函数的参数，进行计算，返回的结果作为一个新的 kv 对，然后再将结果按照 key 进行合并，最后将每个分组的 value 传递给 combine 函数进行计算（先将前两个value 进行计算，将返回结果和下一个 value 传给 combine 函数，以此类推），将 key 与计算结果作为一个新的 kv 对输出。
5）combineByKey(createCombiner: V=>C, mergeValue: (C, V) =>C, mergeCombiners: (C, C) =>C):
对相同 K，把 V 合并成一个集合。

1.createCombiner: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作 createCombiner()的函数来创建那个键对应的累加器的初始值
2.mergeValue: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并 
3.mergeCombiners: 由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的mergeCombiners() 方法将各个分区的结果进行合并。

1) map

➢ 函数签名
def map[U: ClassTag](f: T => U): RDD[U]
➢ 函数说明
将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。

需求1：将数组中每个数乘以2

package com.meiyuan.bigdata.spark.core

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

object Test {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkCore")
    val sc = new SparkContext(sparkConf)
    val rdd = sc.makeRDD(List(1,2,3,4),2)
    // 【1，2】，【3，4】
    rdd.saveAsTextFile("output")
    val mapRDD = rdd.map(_*2)
    // 【2，4】，【6，8】
    mapRDD.saveAsTextFile("output1")
    mapRDD.collect().foreach(println)
    sc.stop()
  }
}

总结：

① rdd的计算一个分区内的数据是一个一个执行逻辑，只有前面一个数据全部的逻辑执行完毕后，才会执行下一个数据
② 分区内数据的执行是有序的。不同分区数据计算是无序的(并行无法确定先后)
③ 一个partition一个task发给Executor不会跨区执行任务
④ 分区不变, 数据转换之后所在的分区位置也不变
 

❖ 小功能：从服务器日志数据 apache.log 中获取用户请求 URL 资源路径

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark01_RDD_Operator_Transform_Test {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - map
        val rdd = sc.textFile("data/apache.log")
        // 数据格式：IP地址+用户ID+访问时间戳+时区+请求方式

        // 这里面的String就是请求资源的路径
        val mapRDD: RDD[String] = rdd.map(
            line => {
                val data = line.split(" ")
                data(6) // 6表示文件位置6(从0开始数)
            }
        )
        mapRDD.collect().foreach(println)

        sc.stop()
    }
}

2) mapPartitions

➢ 函数签名
def mapPartitions[U: ClassTag](
f: Iterator[T] => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
➢ 函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。

需求：分区为2，下面数据一共操作几次？

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark02_RDD_Operator_Transform {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - mapPartitions
        val rdd = sc.makeRDD(List(1,2,3,4), 2)

        // 一个分区数据全部拿到做操作；通过迭代器得到迭代器
        // 内存中的操作, 类似于批处理, 1和2一起操作, 3和4一起操作; 2次
        val mpRDD: RDD[Int] = rdd.mapPartitions(
            iter => {
                // 打印两次
                println(">>>>>>>>>>")
                iter.map(_ * 2) 
            }
        )
        mpRDD.collect().foreach(println)

        sc.stop()
    }
}

总结：

① 以分区为单位进行数据转换操作, 而不是一个一个操作
② 但是会将整个分区的数据加载到内存进行引用
③ 如果处理完的数据是不会被释放掉，存在对象的引用
④ 在内存较小，数据量较大的场合下，容易出现内存溢出。

❖ 小功能：获取每个数据分区的最大值

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark02_RDD_Operator_Transform_Test {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - mapPartitions
        val rdd = sc.makeRDD(List(1,2,3,4), 2)

        // 【1，2】，【3，4】
        //  每个分区最大值【2】，【4】
        val mpRDD = rdd.mapPartitions(
            iter => {
        // 迭代器得到迭代器，求迭代器最大值是一个值所以需要包起来变成迭代器
                List(iter.max).iterator 
            }
        )
        mpRDD.collect().foreach(println)
        sc.stop()
    }

}

面试题：map和mapPartitions的区别？
➢ 数据处理角度
Map算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。
➢ 功能的角度
Map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据
➢ 性能的角度
Map算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。使用map操作。

3) mapPartitionsWithIndex

➢ 函数签名
def mapPartitionsWithIndex[U: ClassTag](
f: (Int, Iterator[T]) => Iterator[U],
preservesPartitioning: Boolean = false): RDD[U]
➢ 函数说明
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。

需求1：求数字的分区

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark03_RDD_Operator_Transform1 {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - mapPartitionsWithIndex
        val rdd = sc.makeRDD(List(1,2,3,4))

        val mpiRDD = rdd.mapPartitionsWithIndex(
            (index, iter) => {
                // 求数字的分区(分区号码, 数字)（一共8个分区）
                // 1,   2,    3,   4
                //(1,1)(3,2),(5,3),(7,4)
                iter.map(
                    num => {
                        (index, num)
                    }
                )
            }
        )
        mpiRDD.collect().foreach(println)
        sc.stop()
    }
}

❖ 小功能：获取第二个数据分区的数据

4) flatMap

➢ 函数签名
def flatMap[U: ClassTag](f: T => TraversableOnce[U]): RDD[U]
➢ 函数说明
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射

需求：拆词

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark04_RDD_Operator_Transform1 {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - flatMap
        val rdd: RDD[String] = sc.makeRDD(List(
            "Hello Scala", "Hello Spark"
        ))
        
        // 一个字符串拆成一个一个单词
        // 简约写法 val flatRDD: RDD[String] = rdd.flatMap(_.split(" "))
        val flatRDD: RDD[String] = rdd.flatMap(
            s => {
                s.split(" ")
            }
        )
        flatRDD.collect().foreach(println)
        sc.stop()
    }
}

❖ 小功能：将List(List(1,2),3,List(4,5))进行扁平化操作

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark04_RDD_Operator_Transform2 {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - flatMap
        val rdd = sc.makeRDD(List(List(1,2),3,List(4,5)))

        val flatRDD = rdd.flatMap(
            data => {
                data match {
                    case list:List[_] => list
                    case dat => List(dat)
                }
            }
        )
        flatRDD.collect().foreach(println)
        sc.stop()
    }
}

5) glom

➢ 函数签名
def glom(): RDD[Array[T]]
➢ 函数说明
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变

List => Int 整体拆成个体flatMap操作
Int => Array 相反的操作，个体变成整体，glom操作

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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


/**
  * @author meiyuan
  * @create 2021-09-17 2:59 PM
  */
object Spark05_RDD_Operator_Transform {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
        // TODO 算子 - glom
        val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4), 2)
        val glomRDD: RDD[Array[Int]] = rdd.glom()
        // data是两个分区的两个数组, 所以需要循环
        // 1,2
        // 3,4
        glomRDD.collect().foreach(data => println(data.mkString(",")))
        sc.stop()
    }
}

❖ 小功能：计算所有分区最大值求和（分区内取最大值，分区间最大值求和）

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark05_RDD_Operator_Transform_Test {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - glom
        val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4), 2)

        // 【1，2】，【3，4】
        // 【2】，【4】 分区内取最大值
        // 【6】 分区之间求和
        // 分区数据变成数组
        val glomRDD: RDD[Array[Int]] = rdd.glom()                                       
        // 求每个分区最大值
        val maxRDD: RDD[Int] = glomRDD.map(
            array => {
                array.max
            } 
        )
        println(maxRDD.collect().sum) // 采集回来也是数组
        sc.stop()
    }
}

6) groupBy

➢ 函数签名
def groupBy[K](f: T => K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[T])]
➢ 函数说明
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中
一个组的数据在一个分区中，但是并不是说一个分区中只有一个组

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark06_RDD_Operator_Transform {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - groupBy
        val rdd : RDD[Int] = sc.makeRDD(List(1,2,3,4), 2)

        // groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
        // 相同的key值的数据会放置在一个组中
        def groupFunction(num:Int) = {
            num % 2
        }

        val groupRDD: RDD[(Int, Iterable[Int])] = rdd.groupBy(groupFunction)
        // (0,CompactBuffer(2, 4))
        // (1,CompactBuffer(1, 3))
        groupRDD.collect().foreach(println)
        sc.stop()
    }
}

❖ 小功能：将List("Hello", "hive", "hbase", "Hadoop")根据单词首写字母进行分组。

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark06_RDD_Operator_Transform1 {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - groupBy
        val rdd  = sc.makeRDD(List("Hello", "hive", "hbase", "Hadoop"), 2)

        // 分组和分区没有必然的关系
        val groupRDD = rdd.groupBy(_.charAt(0))
        // (h,CompactBuffer(hive, hbase))
        // (H,CompactBuffer(Hello, Hadoop))
        groupRDD.collect().foreach(println)
        sc.stop()
    }
}

❖ 小功能：从服务器日志数据apache.log中获取每个时间段访问量。

parse函数是把字符串转换成日期
format函数是把日期转换成字符串

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

import java.text.SimpleDateFormat
import java.util.Date

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

object Spark06_RDD_Operator_Transform_Test {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - groupBy
        val rdd = sc.textFile("data/apache.log")
        // 从服务器日志数据中获取每个时间段的访问量
        val timeRDD: RDD[(String, Iterable[(String, Int)])] = rdd.map(
            line => {
                val data = line.split(" ")
                val time = data(3)
                // 格式化 - 字符串格式需要统一
                val sdf = new SimpleDateFormat("dd/MM/yyyy:HH:mm:ss")
                val date: Date = sdf.parse(time)
                // 字符串格式需要统一
                val sdf1 = new SimpleDateFormat("HH")
                val hour: String = sdf1.format(date) // 时间段
                (hour, 1) // 时间点出现了一次
            }
        ).groupBy(_._1)

        timeRDD.map{
            case ( hour, iter ) => {
                (hour, iter.size)
            }
        }.collect.foreach(println)
        sc.stop()
    }
}

❖ 小功能：WordCount (看part5)

7) filter

➢ 函数签名
def filter(f: T => Boolean): RDD[T]
➢ 函数说明
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。

需求：奇数

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark07_RDD_Operator_Transform {
    def main(args: Array[String]): Unit = {
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
        // TODO 算子 - filter
        val rdd = sc.makeRDD(List(1,2,3,4))
        val filterRDD: RDD[Int] = rdd.filter(num=>num%2!=0)
        filterRDD.collect().foreach(println)
        sc.stop()
    }

}

❖ 小功能：从服务器日志数据apache.log中获取2015年5月17日的请求路径

package com.meiyuan.bigdata.spark.core.rdd.operator.transform

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

object Spark07_RDD_Operator_Transform_Test {
    def main(args: Array[String]): Unit = {

        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)

        // TODO 算子 - filter
        val rdd = sc.textFile("data/apache.log")
        // 从服务器日志数据中获取2015年5月17日的请求路径
        // 不用map是因为不是光返回time, 还要请求路径数据
        rdd.filter(
            line => {
                val data = line.split(" ")
                val time = data(3)
                time.startsWith("17/05/2015")
            }
        ).collect().foreach(println)
        sc.stop()
    }
}

8) sample

➢ 函数签名
def sample(
withReplacement: Boolean,
fraction: Double,
seed: Long = Utils.random.nextLong): RDD[T]
➢ 函数说明
根据指定的规则从数据集中