Spark操作—aggregate

1、aggregate

首先看下 aggregate 函数签名

1	`def` `aggregate[U:` `ClassTag](zeroValue:` `U)(seqOp:` `(U, T)` `=> U, combOp:` `(U, U)` `=> U):` `U`

说明

参数zeroValue：seqOp运算符的每个分区的累积结果的初始值以及combOp运算符的不同分区的组合结果的初始值 - 这通常将是初始元素（例如“Nil”表的列表 连接或“0”表示求和） 
参数seqOp： 每个分区累积结果的聚集函数。 
参数combOp： 一个关联运算符用于组合不同分区的结

应用举例

数据准备

//获取 SparkConf 并设置应用名称*本地模式
  val conf: SparkConf = new SparkConf().setAppName("Spark").setMaster("local[*]")
  //获取 Spark 上下文对象
  val sc: SparkContext = new SparkContext(conf)
  val rdd:RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
  rdd.mapPartitionsWithIndex {
    case (index, data) => {
      println(index + " -> " + data.mkString(","))
    }
      data
  }.collect().foreach(println)

输出

1 2	`1` `->` `3,4` `0` `->` `1,2`

需求1：默认值 0 ，分区内求和，分区间求和

1	`println(rdd.aggregate(0)(_` `+` `_,` `_` `+` `_))`

分析

    /**
     * 0 -> 0 + 1 + 2 => 3
     * 1 -> 0 + 3 + 4 => 7
     * 0 -> 3
     * 1 -> 7
     * 0 + 3 + 7
     * 10 + 0
     * 10
     */

需求2：默认值 10 ，分区内求和，分区间求和

    /**
     * 0 -> 10 + 1 + 2 => 13
     * 1 -> 10 + 3 + 4 => 17
     * 0 -> 13
     * 1 -> 17
     * 10 + 13  + 17  
     * 40
     */

需求3：分区内求最大值，分区间求和

1	`println(rdd.aggregate(2)(math.max(_,` `_),` `_` `+` `_))`

分析

/**
 * 0 -> max(2,1,2) => 2
 * 1 -> max(2,3,4) => 4
 * 0 -> 2
 * 1 -> 4
 * 2 + 2 + 4
 * 8
 */

接下来看下书本上的一个案例

val tuple: (Int, Int) = rdd.aggregate((0, 0))(
  (acc, value) => (acc._1 + value, acc._2 + 1),
  (acc1, acc2) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
)
println(tuple)
println(tuple._1 / tuple._2.toDouble)