Spark算子[11]：reduce、aggregate、fold 详解

以上三个方法操作都是对RDD进行的聚合操作。

1、reduce()与fold()方法是对同种元素类型数据的RDD进行操作，即必须同构。其返回值返回一个同样类型的新元素。

val nums = Array(1,2,3,4,5,6,7,8,9)val numsRdd = sc.parallelize(nums,3)val reduce = numsRdd.reduce((a,b) => a+b)

---

2、fold()与reduce()类似，接收与reduce接收的函数签名相同的函数，另外再加上一个初始值作为第一次调用的结果。（例如，加法初始值应为0，乘法初始值应为1）

val rdd = sc.makeRDD(List("a","a","b","b"),4)val res = rdd.fold("")(_+_)

具体案例请参考： Spark算子[10]：foldByKey、fold 源码实例详解

---

3、aggregate() 方法可以对两个不同类型的元素进行聚合，即支持异构。
它先聚合每一个分区里的元素，然后将所有结果返回回来，再用一个给定的conbine方法以及给定的初始值zero value进行聚合。

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

由以上可以看到，(zeroValue: U)是给定一个初值，后半部分有两个函数，seqOp与combOp。
seqOp相当于是在各个分区里进行的聚合操作，它支持(U,T)=>U，也就是支持不同类型的聚合。
combOp是将seqOp后的结果再进行聚合，此时的结果全部是U类，只能进行同构聚合。

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        }      }.collectres16: Array[(String, List[Int])] = Array((part_0,List(5, 4, 3, 2, 1)), (part_1,List(10, 9, 8, 7, 6)))

##第一个分区中包含5,4,3,2,1

##第二个分区中包含10,9,8,7,6

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

结果为什么是58，看下面的计算过程：

##先在每个分区中迭代执行 (x : Int,y : Int) => x + y 并且使用zeroValue的值1

## part_0中 zeroValue+5+4+3+2+1 = 1+5+4+3+2+1 = 16

## part_1中 zeroValue+10+9+8+7+6 = 1+10+9+8+7+6 = 41

##再将两个分区的结果合并(a : Int,b : Int) => a + b ，并且使用zeroValue的值1

##即：zeroValue+part_0+part_1 = 1 + 16 + 41 = 58

---

fold

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

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

scala> rdd1.fold(1)(     |       (x,y) => x + y         |     )res19: Int = 58##结果同上面使用aggregate的第一个例子一样，即：scala> rdd1.aggregate(1)(     |           {(x,y) => x + y},      |           {(a,b) => a + b}     |     )res20: Int = 58

案例参考与：lxw的大数据田地