Spark中RDD的算子

1、算子的简单介绍

Transformation(转换)算子:根据数据集创建一个新的数据集,计算后返回一个新RDD,例如一个rdd进行map操作后生了一个新的rdd。

Action(动作)算子:对rdd结果计算后返回一个数值value给驱动程序(driver),例如collect算子将数据集的所有元素收集完成返回给驱动程序。

控制算子:对数据集进行特殊操作,例如cache算子将对于重复使用的算子,进行cache做缓存使用,数据只保存在内存中,性能提升。

懒执行:Spark中转化算子和控制算子是懒执行的,需要Action算子触发才能执行。

懒执行就是延迟计算的意思,就像是创建了一个视图,他并不是把查询好的数据放入视图了,而是当你需要这些数据时,查看视图时,他才执行定义视图时候的SQL语句。

注意:

Driver即运行Application的main()函数并且创建SparkContext。

Application用户编写的Spark应用程序。

SparkContext整个应用的上下文、控制应用的生命周期。

job即在每一个application中,有几个action,就会产生几个job。

2、算子的使用

2.1、常用的Transformation算子

    val conf = new SparkConf().setAppName("WordCount").setMaster("local")
    val sc = new SparkContext(conf)
    val pairRdd = sc.parallelize(List((1,1), (5,10), (5,9), (2,4), (3,5), (3,6),(4,7), (4,8),(2,3), (1,2)),4)
    //map(函数)，一一映射，分区数量不变，有多少条数据，就被会运行多少次。
    val value1: RDD[(Int, Int)] = pairRdd.map(x => (x._1, x._2 + 1))

    //定义一个迭代函数
    val f1 = (iter:Iterator[(Int, Int)]) => iter.map(x=>(x._1,x._2*2))
    //mapPartitions函数可以认为是Map的变种，可以对分区进行并行处理，两者的区别是调用的颗粒度不一样，map的输入函数是应用于RDD的每个元素，而mapPartition的输入函数是应用于RDD的每个分区。
    val value2: RDD[(Int, Int)] = pairRdd.mapPartitions(f1)

    //定义一个迭代函数
    val f2 = (index:Int,iter:Iterator[(Int, Int)]) => iter.map((index,_))
    //mapPartitionsWithIndex函数类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]
    val value3: RDD[(Int, (Int, Int))] = pairRdd.mapPartitionsWithIndex(f2)

    //filter函数,返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成,fitler并不会改变分区的数量，之前有几个，现在仍然有几个分区。
    val value4: RDD[(Int, Int)] = pairRdd.filter(x => x._2 % x._1 == 0)

    //flatMap函数: map之后，再flatten。每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
    val value5: RDD[Char] = pairRdd.flatMap(x => x._1.toString + x._2.toString)

    //groupByKey函数:在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD,可重新指定分区个数
    val value6: RDD[(Int, Iterable[Int])] = pairRdd.groupByKey(1)

    //groupBy函数与groupByKey类似,底层调用groupByKey,返回一个(K, Iterator[V])的RDD,可重新指定分区个数
    val value7: RDD[(Int, Iterable[(Int, Int)])] = pairRdd.groupBy(_._1, 1)
    //groupBy后要搭配MapValues()使用

    //reduceByKey函数:在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
    val value8: RDD[(Int, Int)] = pairRdd.reduceByKey(_ + _, 1)

    //aggregateByKey 聚合类算子：初始化在每一个分区聚合中参数运行，但是在全局聚合中，不参与,类似于reduceByKey,但多个初始值
    val value11: RDD[(Int, Int)] = pairRdd.aggregateByKey(100)(_ + _, _ + _)

    //sortByKey函数:在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD,是全局排序,可指定分区数量
    //可设置排序规则,默认是从小到大排序，是true， 如果想从大到小排，设置为false
    val value12: RDD[(Int, Int)] = pairRdd.sortByKey(false,2)

    //sortBy函数:与sortByKey类似，但是更灵活,可设置排序的字段
    val value13: RDD[(Int, Int)] = pairRdd.sortBy(_._1, false, 2)

    //union函数:对源RDD和参数RDD求并集后返回一个新的RDD
    val value14: RDD[(Int, Int)] = value1.union(value2)

    //intersection函数:对源RDD和参数RDD求交集后返回一个新的RDD
    val value15: RDD[(Int, Int)] = value1.intersection(value2)

    //subtract函数:对源RDD和参数RDD求差集后返回一个新的RDD
    val value16: RDD[(Int, Int)] = value1.subtract(value2)

    //join函数:对源RDD和参数RDD进行join返回一个新的RDD
    val value17: RDD[(Int, (Int, Int))] = value1.join(value2)

    //cogroup函数:对源RDD和参数RDD进行全外关联返回一个新的RDD,相当于SQL中的全外关联full outer join，返回左右RDD中的记录，关联不上的为空。
    val value18: RDD[(Int, (Iterable[Int], Iterable[Int]))] = value1.cogroup(value2)

    //cartesian函数:对源RDD和参数RDD进行笛卡尔积返回一个新的RDD
    val value19: RDD[((Int, Int), (Int, Int))] = value1.cartesian(value2)

    //coalesce:对RDD重新进行分区
    val value20: RDD[((Int, Int), (Int, Int))] = value19.coalesce(10)

    //repartition:类似于coalesce方法，底层就是用的coalesce方法，对RDD重新进行分区
    val value21: RDD[((Int, Int), (Int, Int))] = value20.repartition(5)

    //去重：distinct(分区数量)。
    val value22: RDD[((Int, Int), (Int, Int))] = value19.distinct(12)
    //等价于
    val value23: RDD[((Int, Int), (Int, Int))] =value19.map(x=>(x,null)).reduceByKey((x,y) => x).map(_._1)

2.2、常用的ACtion算子

    //reduce函数与reduceByKey类似,返回一个结果的RDD,+ ,++ 取决rdd的元素类型,string类型使用++
    val value9: Int = pairRdd.map(_._2).reduce(_ + _)

    //aggregate 聚合类算子：存在两次聚合。局部聚合和全局聚合。
    //先局部计算(100+分区一的内容)  (100+分区二的内容)+...
    //再全局计算100+(100+分区一的内容)+ (100+分区二的内容)+...
    val value10: Int = pairRdd.map(_._2).aggregate(100)(_ + _, _ + _)

    //collect 在驱动程序中，以数组的形式返回数据集的所有元素
    val tuples: Array[((Int, Int), (Int, Int))] = value21.collect()

    //foreach 在数据集的每一个元素上，运行函数func
    val unit: Unit = value11.foreach(println(_))

    //foreach 迭代的是每一个分区的数据
    //如果我们需要去获取mysql的连接，RDD中有10000 条数据，有10个分区。
    //foreach：获取10000次连接，性能低下。
    //foreapartition: 只需要获取10次连接，每一个分区中的数据，共用一个连接。 性能优越。
    value21.foreachPartition(println(_))

    //saveAsTextFile 将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
    value21.saveAsTextFile("路径")

    //count()	返回RDD的元素个数
    val tuples1: Array[((Int, Int), (Int, Int))] = value19.collect()

    //first()	返回RDD的第一个元素（类似于take(1)）
    val tuple: ((Int, Int), (Int, Int)) = value19.first()

    //take(n)	返回一个由数据集的前n个元素组成的数组
    val tuples2: Array[((Int, Int), (Int, Int))] = value19.take(10)

注意：

sortBy 是按照 RangePartitioner作为分区器

groupByKey  和 reduceByKey 中优先使用reduceByKey,因为reduceByKey会有一个局部的聚合,性能更好。

ByKey的都是转换算子,没有Key的都是action类算子。aggregateByKey和reduceByKey是转化算子,aggregate和reduce是执行算子

2.3、控制算子

cache	对于重复使用的算子,进行cache做缓存使用,数据只保存在内存中,性能提升
persist	性能提升
checkPoint	数据容错,当数据计算的时候,机器挂了,重新追溯到checkPoint的目录下checkPoint是将RDD持久化到磁盘中,还可以切断RDD之间的依赖关系