Spark函数讲解：aggregateByKey

该函数和aggregate类似，但操作的RDD是Pair类型的。Spark 1.1.0版本才正式引入该函数。官方文档定义：

Aggregate the values of each key, using given combine functions and a neutral "zero value". This function can return a different result type, U, than the type of the values in this RDD, V. Thus, we need one operation for merging a V into a U and one operation for merging two U's, as in scala.TraversableOnce. The former operation is used for merging values within a partition, and the latter is used for merging values between partitions. To avoid memory allocation, both of these functions are allowed to modify and return their first argument instead of creating a new U.

　　aggregateByKey函数对PairRDD中相同Key的值进行聚合操作，在聚合过程中同样使用了一个中立的初始值。和aggregate函数类似，aggregateByKey返回值的类型不需要和RDD中value的类型一致。因为aggregateByKey是对相同Key中的值进行聚合操作，所以aggregateByKey函数最终返回的类型还是Pair RDD，对应的结果是Key和聚合好的值；而aggregate函数直接是返回非RDD的结果，这点需要注意。在实现过程中，定义了三个aggregateByKey函数原型，但最终调用的aggregateByKey函数都一致。

函数原型

1	def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)

2	(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

3	def aggregateByKey[U: ClassTag](zeroValue: U, numPartitions: Int)

4	(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

5	def aggregateByKey[U: ClassTag](zeroValue: U)

6	(seqOp: (U, V) => U, combOp: (U, U) => U): RDD[(K, U)]

　　第一个aggregateByKey函数我们可以自定义Partitioner。除了这个参数之外，其函数声明和aggregate很类似；其他的aggregateByKey函数实现最终都是调用这个。
　　第二个aggregateByKey函数可以设置分区的个数(numPartitions)，最终用的是HashPartitioner。
　　最后一个aggregateByKey实现先会判断当前RDD是否定义了分区函数，如果定义了则用当前RDD的分区；如果当前RDD并未定义分区 ，则使用HashPartitioner。

实例

01

/**

02	* User: 过往记忆

03	* Date: 15-03-02

04	* Time: 上午06:30

05	* bolg: http://www.iteblog.com

06	* 本文地址：http://www.iteblog.com/archives/1261

07	* 过往记忆博客，专注于hadoop、hive、spark、shark、flume的技术博客，大量的干货

08	* 过往记忆博客微信公共帐号：iteblog_hadoop

09

*/

10

11	scala> var data = sc.parallelize(List((1,3),(1,2),(1, 4),(2,3)))

12	scala> def seq(a:Int, b:Int) : Int ={

13	| println("seq: " + a + "\t " + b)

14	| math.max(a,b)

15

| }

16	seq: (a: Int, b: Int)Int

17

18	scala> def comb(a:Int, b:Int) : Int ={

19	| println("comb: " + a + "\t " + b)

20

| a + b

21

| }

22	comb: (a: Int, b: Int)Int

23	scala> data.aggregateByKey(1)(seq, comb).collect

24	seq: 1   3

25	seq: 1   2

26	seq: 1   4

27	seq: 1   3

28	comb: 3  2

29	comb: 5  4

30	res62: Array[(Int, Int)] = Array((1,9), (2,3))

注意

　　细心的读者肯定发现了aggregateByKey和aggregate结果有点不一样。如果用aggregate函数对含有3、2、4三个元素的RDD进行计算，初始值为1的时候，计算的结果应该是10，而这里是9，这是因为aggregate函数中的初始值需要和reduce函数以及combine函数结合计算，而aggregateByKey中的初始值只需要和reduce函数计算，不需要和combine函数结合计算，所以导致结果有点不一样。