spark算子(五)--action算子

Collect

package com.doit.spark.demoDay05

import org.apache.spark.SparkContext

/**
  * @author 向阳木
  * @date 2020/09/22/ 22:19
  * @Description:
  *              将数据以数组形式收集回Driver端，数据按照分区编号有序返回
  *              按照分区编号收集到内存中,内存中有一个阈值,达到上限后,便不会收集
  */
object CollectDemo {
  def main(args: Array[String]): Unit = {
      val sc: SparkContext = uint.getSc
      val rdd1 = sc.parallelize(List(1,2,3,4,5), 2)
       println(rdd1.collect().toBuffer)
  }

}

ActionDemo

package com.doit.spark.demoDay05

import org.apache.spark.SparkContext

/**
  * @author 向阳木
  * @date 2020/09/22/ 22:26
  * @Description:
  */
object ActionDemo {
  def main(args: Array[String]): Unit = {
    val sc: SparkContext = uint.getSc
    val rdd1 = sc.parallelize(List(1,2,3,4,5), 2)

    /**count  返回RDD元素的数量
      * 底层会调用iterable读取每个分区的数据.然后+1 , 把各个分区的条数放到数组中,
      * 然后返回到driver端进行聚合
      */
    val l: Long = rdd1.count()
    println(l) //5
    /**
      * reduce  将数据以输入的函数进行聚合返回一个值
      * 此算子不会产生shuffle
      * 底层实现原理: 先局部聚合,然后在进行全局聚合,此过程都是在executor端聚合
      * 然后将结果返回到driver端
      */
    val res2: Int = rdd1.reduce(_+_)
    println(res2) //15

    /** aggregate   传入一个初始值,然后传入两个函数,第一个函数为局部聚合函数,第二个函数为全局聚合函数
      * 注意:
      * 局部聚合每个分区,全局聚合都会应用初始值,
      * 和aggregateByKey不同,aggregateByKey只会在局部聚合时应用初始值
      *
      * aggregate中的task并行执行,谁先执行完毕就会把谁放在最前边
      */
    val res3: Int = rdd1.aggregate(1000)(_+_,_+_) //3015 RDD1 两个分区再加上全局聚合一个加了3次1000
    val res4: String = rdd1.aggregate("#")(_+_,_+_) //##345#12  此结果也可能为 ##12#345 task并行执行,谁先执行完毕就会把谁放在最前边
    println(res4)
    println(res3)

    /**
      * take(n) 将前n个数据取出
      * 底层原理:
      *     take取数据时可能触发多次job 因为在take取数据的时候,会一个分区一个分区的取数据,
      *     将第一个分区的数据,取完后才会取下个分区的数据,因此会触发action
      *     将来读几个分区的数据就会触发几次的action 当然最多触发次数为分区数量
      */
    val res5: Array[Int] = rdd1.take(3)
    res5.foreach(println)// 1 2 3

    /**  takeOrdered(n)  默认升序,返回前n个值 和top类似
      *      柯力化方法有隐式参数
      *      可以重写饮食参数来改变排序规则
      *      底层实现原理:
      *             先将分区内的数据放到有界优先队列(BoundedPriorityQueue),放n个
      *             然后全局聚合,有界优先队列合并(此合并两个有n个数据的队列,聚合后产生一个有n个符合要求的数据的队列).
      *             最终聚合出想要的结果  此过程中没有shuffle
      */
    val rdd2 = sc.parallelize(List(3,2,4,1,5), 2)
    val res6: Array[Int] = rdd2.takeOrdered(3)
   res6.foreach(println) // 1 2 3

    /**
      * first  取出第一个值
      * 底层原理:
      *       用take实现  take(1)
      */
    val res7: Int = rdd2.first()
    println(res7) // 3

    /**
      * min/max 获取最小值/最大值
      * 底层实现原理:
      *         底层由reduce实现,一个分区和另一个分区比较获取最大/最小值
      *         然后在全局比较得到max/min
      */
    val res8: Int = rdd2.min()
    val res9: Int = rdd2.max()
    println(s"最大值: $res9  最小值: $res8") //最大值: 5  最小值: 1

    /**
      * saveAsTextFile   以文件的形式保存到文件系统中
      */
    rdd2.saveAsTextFile("D:\\data\\out02")

    /**   foreach
      * 将数据一条一条的取出来，传入一个函数，这个函数返回Unit，
      * 比如传入一个打印的逻辑，
      * 注意:
      *    打印的结果在Executor端的日志中
      */
    rdd2.foreach(x => println(x))

    /**foreachPartition
      * 以分区位单位，每一个分区就是一个Task，以后可以将数据写入到数据库中，一个分区一个连接，效率更高
      */
    rdd2.foreachPartition(it => {
      it.foreach(println)
    })

  }

}