行动算子(常用和整数型)

1.行动算子介绍

• 返回的不是一个RDD，而是一个数据值或者集合或者是没有返回
• 没有行动算子算法，那么无法实现转换算子的执行

2.reduce(fun):T 聚合算子

• 定义：fun函数类型如下 （T,T）=>T T是RDD的数据集数据的类型
  将原先RDD数据集中聚合起来算一个总的结果 sum/count/
• 解释：reduce算子是对RDD数据集中每一个数据都要进行聚合操作
• 案例：

def reduceOper(sc: SparkContext): Unit ={
  val rdd = sc.makeRDD(Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 0))
 
  // sum聚合函数 a是上一次聚合之后的结果  b是当前数据
  val sum: Int = rdd.reduce((a: Int, b: Int) => {
    println(s"a=$a, b=$b")
    a+b
  })
  println(rdd.getNumPartitions) // 2个分区
  println(sum) // 45
 
  // 求最大值
  val max: Int = rdd.reduce((a: Int, b: Int) => {
    println(s"a=$a, b=$b")
    if (a > b) {
      a
    } else {
      b
    }
  })
  println(rdd.getNumPartitions) // 2
  println(max)
 
  // 求最小值
  val min: Int = rdd.reduce((a: Int, b: Int) => {
    println(s"a=$a, b=$b")
    if (a < b) {
      a
    } else {
      b
    }
  })
  println(rdd.getNumPartitions) // 2
  println(min)
}

3.aggregate 聚合算子，属于一种柯里化应用类型的算子

• 定义：aggregate (zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)：U
  zeroValue 初始值
  seqOp函数 对RDD数据集中的每一个分区和zeroValue取一个聚合操作 得到一个结果
  combOp函数 将每个分区通过seqOp函数计算出来的结果和zeroValue聚合操作得到一个最终结果
• 解释：聚合算子，属于一种柯里化应用类型的算子
• 案例：

def aggregateIOper(sc:SparkContext):Unit={
  val rdd:RDD[Int] = sc.makeRDD(Array(12,456,413,458,85,2,15,6,3),4);
 
  // 计算rdd数据集中累加结果
  val res:Int = rdd.aggregate(1)(
    /*
        对每个分区操作
        对RDD数据集中的每个分区和初始值取一个聚合操作
        共有4个分区，一共+4
    */
    (a: Int, b: Int) => {
      a + b
    },
    /*
        对所有分区聚合操作
        每个分区计算出来的结果总值和初始值取一个聚合操作
        与初始值作聚合操作，一共+1
    */
    (a: Int, b: Int) => {
      a + b
    }
  )
  println("sum值：" + res) // sum值：1455
 
  // 计算rdd数据集中最大值和最小值
  val min = rdd.aggregate(rdd.first())(
    (a: Int, b: Int) => {
      if (a < b) {
        a
      } else {
        b
      }
    },
    (a: Int, b: Int) => {
      if (a < b) {
        a
      } else {
        b
      }
    }
  )
  println("最小值：" + min) // 最小值：2
}

4. collect():Array[T] -----慎用

• 定义：将RDD数据集中的全部数据拉取到Driver所在节点形成一个数组，数组包含RDD数据集中的所有数据，数组内存中的概念
• 案例：

def collectOper(sc: SparkContext):Unit={
  val rdd = sc.makeRDD(Array(20,30,11,15,16,19,22,26,17,45,54,99))
  val array:Array[Int] = rdd.collect()
  println(array.mkString(",")) // 20,30,11,15,16,19,22,26,17,45,54,99
}

5. count():Long 求总数

• 案例：

def countOper(sc: SparkContext):Unit={
  val rdd = sc.makeRDD(1 to 100)
  val count = rdd.count()
  println(count) // 100
}

6.saveAsTextFile（path）数值型RDD专用

• 解释：将rdd计算出来的结果集保存到本地或者是HDFS分布式文件存储系统
• 案例：

def saveAsXXXOper(sc: SparkContext):Unit={
  val rdd = sc.makeRDD(1 to 100)
  rdd.saveAsTextFile("hdfs://node1:9000/action")
}

7.take(n) takeSample(true/false,num)

• 案例：

def take(sc: SparkContext) = {
  val rdd = sc.makeRDD(1 to 100)
  // first():T   获取RDD数据集中第一条数据
  val first: Int = rdd.first()
  println(first) // 1
 
  val take: Array[Int] = rdd.take(3)
  // take(n) :Array[T]  获取RDD数据集中前N条数据
  println(take.mkString(",")) // 1,2,3
 
  // takeSample(withReplacement, num, [seed])  抽样，抽取几条数据
  val takeSample: Array[Int] = rdd.takeSample(true, 2)
  println(takeSample.mkString("=")) // 4=28
 
  // takeOrdered(num):Array[T] 将RDD数据集元素排序之后获取前num条数据  默认是升序排序
  val value = sc.makeRDD(Array(2324, 122, 34, 324, 12, 2))
  var takeorder = value.takeOrdered(3)
  println(takeorder.mkString("-")) // 2-12-34
}

8.foreach函数

foreach(func) 无返回值  一般用于累加器计算或者RDD数据集的遍历操作
func函数无返回值类型的函数

9.整数型RDD特有的统计操作----行动算子

object CountRDD {
  def main(args: Array[String]): Unit = {
    val sparkConf:SparkConf = new SparkConf().setAppName("zhengshu").setMaster("local")
    val sc:SparkContext = new SparkContext(sparkConf)
    val rdd:RDD[Int] = sc.makeRDD(Array(1, 2, 3, 4, 5, 6, 7, 8))
    val rdd1:RDD[String] = sc.makeRDD(Array("zs","ls","ww"))
    println(s"rdd的累加和${rdd.sum()}")
    println(s"rdd的最大值${rdd.max()}")
    println(s"rdd的累最小值${rdd.min()}")
    println(s"rdd的平均值${rdd.mean()}")
    println(s"rdd的方差${rdd.variance()}")
    println(s"rdd的标准差${rdd.stdev()}")
    sc.stop()
  }
}