spark-单RDD算子-聚合算子

一、aggregate

顾名思义，聚合，但不同于reduce这种，aggregate粒度更细，可以设置分区内数据的聚合函数和分区之间的聚合函数。也就是说，aggregate需要2个函数参数，同时，也需要1个基准值。
聚合，就需要多变少，也就是说，需要累加计算。

格式

zeroValue的类型即结果的类型

def aggregate[U]
(zeroValue: U)
(
seqOp: (U, T) ⇒ U, //分区内聚合函数，U是zeroValue的类型，T是分区内数据的类型
combOp: (U, U) ⇒ U //分区间聚合函数，U是zeroValue的类型，U是返回值类型。
)
(implicit arg0: ClassTag[U]): U

1. example1

{1} 数据准备

创建1个2个分区的rdd。第一个分区中包含5,4,3,2,1、第二个分区中包含10,9,8,7,6

var rdd1 = sc.makeRDD(1 to 10,2)
rdd1.mapPartitionsWithIndex{
        (partIdx,iter) => {
          var part_map = scala.collection.mutable.Map[String,List[Int]]()
            while(iter.hasNext){
              var part_name = "part_" + partIdx;
              var elem = iter.next()
              if(part_map.contains(part_name)) {
                var elems = part_map(part_name)
                elems ::= elem
                part_map(part_name) = elems
              } else {
                part_map(part_name) = List[Int]{elem}
              }
            }
            part_map.iterator
           
        }
      }.collect
res16: Array[(String, List[Int])] = Array((part_0,List(5, 4, 3, 2, 1)), (part_1,List(10, 9, 8, 7, 6)))

{2} 基准值是1，分区内聚合函数是累加，分区间聚合函数还是累加。结果是58

scala> rdd1.aggregate(1)(
     |           {(x : Int,y : Int) => x + y}, 
     |           {(a : Int,b : Int) => a + b}
     |     )
res17: Int = 58

计算过程

1. 先在每个分区中迭代执行 (x : Int,y : Int) => x + y 并且使用zeroValue的值1。
   即：part_0中 zeroValue+5+4+3+2+1 = 1+5+4+3+2+1 = 16
2. part_1中 zeroValue+10+9+8+7+6 = 1+10+9+8+7+6 = 41
3. 再将两个分区的结果合并(a : Int,b : Int) => a + b ，并且使用zeroValue的值1。
   即：zeroValue+part_0+part_1 = 1 + 16 + 41 = 58

{3} 基准值是2，分区内聚合函数是累加，分区间聚合函数还是累乘。

scala> rdd1.aggregate(2)(
     |           {(x : Int,y : Int) => x + y}, 
     |           {(a : Int,b : Int) => a * b}
     |     )
res18: Int = 1428

计算过程

这次zeroValue=2
part_0中 zeroValue+5+4+3+2+1 = 2+5+4+3+2+1 = 17
part_1中 zeroValue+10+9+8+7+6 = 2+10+9+8+7+6 = 42
最后：zeroValuepart_0part_1 = 2 * 17 * 42 = 1428

二、fold

fold是aggregate的简化，将aggregate中的seqOp和combOp使用同一个函数op。

def fold(zeroValue: T)(op: (T, T) ⇒ T): T

1. example

scala> rdd1.fold(1)(
     |       (x,y) => x + y    
     |     )
res19: Int = 58

等价于

scala> rdd1.aggregate(1)(
     |           {(x,y) => x + y}, 
     |           {(a,b) => a + b}
     |     )
res20: Int = 58