Spark算子：RDD行动Action操作–aggregate、fold、lookup；reduce/fold/aggregate区别

清疚 2021-09-25 01:26 310阅读 0赞

关键字：Spark算子、Spark函数、Spark RDD行动Action、aggregate、fold、lookup

## aggregate ##

def aggregate\[U\](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag\[U\]): U

aggregate用户聚合RDD中的元素，先使用seqOp将RDD中每个分区中的T类型元素聚合成U类型，再使用combOp将之前每个分区聚合后的U类型聚合成U类型，**特别注意seqOp和combOp都会使用zeroValue的值**，zeroValue的类型为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
    
    }
    }.collect
    res16: 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

var rdd1 = sc.makeRDD(1 to 10,2)
    rdd1.aggregate(1)(
                    {(x : Int,y : Int) => x + y}, 
                    {(a : Int,b : Int) => a + b}
                    )
    res0: 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

再比如：

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

\#\#最后：**zeroValue**\*part\_0\*part\_1 = 2 \* 17 \* 42 = 1428

因此，**zeroValue即确定了U的类型，也会对结果产生至关重要的影响**，使用时候要特别注意。

## 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
    
    
    
    var rdd1 = sc.makeRDD(1 to 10,4)
    rdd1.fold(3)(_+_)
    res4: Int = 70
    
    [(3+1+2+3)+(3+4+5+6)+(3+7+8)+(3+9)]+3 = 55+(4+1)*3 = 75 ;4+1是4个分区计算4次，每次加3；最后多个分区结果合并需要再加一次3
    
    
    var rdd1 = sc.makeRDD(1 to 10,3)
    rdd1.fold(5)(_+_)
    res5: Int = 75 = 55+（3+1）*5

## lookup ##

def lookup(key: K): Seq\[V\]

lookup用于(K,V)类型的RDD,指定K值，返回RDD中该K对应的所有V值。

scala> var rdd1 = sc.makeRDD(Array(("A",0),("A",2),("B",1),("B",2),("C",1)))
    rdd1: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[0] at makeRDD at :21
    
    scala> rdd1.lookup("A")
    res0: Seq[Int] = WrappedArray(0, 2)
    
    scala> rdd1.lookup("B")
    res1: Seq[Int] = WrappedArray(1, 2)

转自：http://lxw1234.com/archives/2015/07/394.htm

\-----

reduce/fold/aggregate 三个方法操作都是对RDD进行的聚合操作。

**foldByKey与aggregateByKey，fold与aggregate用法相近，作用相似！  
foldByKey是aggregateByKey的简化，fold是aggregate的简化。**

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)
    reduce: Int = 45

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

val rdd = sc.makeRDD(List("a","a","b","b"),4)
    val res = rdd.fold("")(_+_) //结果不固定
    res: String = baab
    或者
    res: String = abba

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

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

[Spark_10_foldByKey_fold]: http://blog.csdn.net/leen0304/article/details/78789564