对combineByKey的理解,aggregateByKey
参数：(createCombiner: V => C, mergeValue: (C, V) => C, mergeCombiners: (C, C) => C)
1.作用：对相同K，把V合并成一个集合。
2.参数描述：
（1）createCombiner:
combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素,combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值
（2）mergeValue:
如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并
（3）mergeCombiners:
由于每个分区都是独立处理的， 因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器， 就需要使用用户提供的 mergeCombiners() 方法将各个分区的结果进行合并。
3.需求：创建一个pairRDD，根据key计算每种key的均值。（先计算每个key出现的次数以及可以对应值的总和，再相除得到结果）
4.需求分析：
（1）创建一个pairRDD
scala> val input =
sc.parallelize(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)),2)
input: org.apache.spark.rdd.RDD[(String, Int)] =
ParallelCollectionRDD[52] at parallelize at <console>:26
（2）将相同key对应的值相加，同时记录该key出现的次数，放入一个二元组
scala> val combine = input.combineByKey((_,1),(acc:(Int,Int),v)=>(acc._1+v,acc._2+1),(acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))
combine: org.apache.spark.rdd.RDD[(String, (Int, Int))] = ShuffledRDD[5] at combineByKey at <console>:28
（3）打印合并后的结果
scala> combine.collect
res5: Array[(String, (Int, Int))] = Array((b,(286,3)), (a,(274,3)))
（4）计算平均值
scala> val result = combine.map{case (key,value) => (key,value._1/value._2.toDouble)}
result: org.apache.spark.rdd.RDD[(String, Double)] = MapPartitionsRDD[54] at map at <console>:30
（5）打印结果
scala> result.collect()
res33: Array[(String, Double)] = Array((b,95.33333333333333), (a,91.33333333333333))
理解：
1.首先是分区
我理解的，对这样的Array数组分区 就是根据个数来切分 分区的
比如上面我有两个分区 那么我就中间切开 将两边的数据放进两个分区，
对不对不知道、、、
通过glom算子查看分区结果：
定义2个分区
val input = sc.parallelize(Array(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98)),2)
-------------------------------------------------------------
分区结果
scala> input.glom.collect
res1: Array[Array[(String, Int)]] = Array(Array((a,88), (b,95), (a,91)), Array((b,93), (a,95), (b,98)))
-----------------------------------------------------
即 两个分区
Array((a,88), (b,95), (a,91))
Array((b,93), (a,95), (b,98))
-----------------------------------------
2.三个操作 （createCombiner，mergeValue，mergeCombiners）
前两个操作是分区内的，第三个操作是分区间
因为这个算子的名字combineByKey，是ByKey 通过key来分组操作的
对第一个操作的理解，createCombiner, 其实就是 初始化
（可以先看看上一篇博客的scala中的 Scala中的fold和reduce理解）
那到底怎么初始化呢
首先 我们已经分区了 每个分区都是相同的操作，
所以第一个分区为例： Array((a,88), (b,95), (a,91))
ByKey嘛，所以 有两个key a， b
a ： 88, 91
b ： 95
这第一个操作createCombiner：
记住昂
是对相同的key取(第)一个，做初始化操作，
所以操作是这个 (_,1) 结果 就是
a ： (88, 1) , 91
b : (95, 1)
注意 对于相同的key只挑选一个（一般是第一个）做初始化操作
这个操作的结果 就叫 acc
所以下一个操作的第一个参数 acc 的类型是 acc : (Int, Int)
第二个参数v 就是 相同key的其他值 比如 a 的 91
所以我们第二个操作mergeValue的逻辑根据题目要求可以是：
mergeValue
(acc:(Int,Int),v)=>(acc._1+v,acc._2+1)
对于相同key 值相加起来，此处每次操作加1 以记录次数
两个分区出来的结果是:
第一个分区：
a ： ( 179, 2) ,
b : (95, 1)
第二个分区
a ： (95,1)
b : (191, 2)
第三个操作mergeCombiners就是分区间的操作
(acc1:(Int,Int),acc2:(Int,Int))=>(acc1._1+acc2._1,acc1._2+acc2._2))
根据key将第一二个参数相加
结果的类型 [(String, (Int, Int))]
所以是 （a，（274，3）），（b，（286,3））
OK 很简单
感觉需要注意的：
1.就是第一 二个操作是分区内操作，第三个是分区间操作，
且第一个操作为初始化操作，
且在分区下相同的key只执行一次初始化操作，一般是挑选key的第一个V值作为操作对象
同理，
因为 aggregateByKey 底层调用的也是 combineByKey 所以两者是差不多的,
其第一个操作 zeroValue也是 ：给每一个分区中的每一个key一个初始值；
参数：(zeroValue:U,[partitioner: Partitioner]) (seqOp: (U, V) => U,combOp: (U, U) => U)
- 作用：在kv对的RDD中，，按key将value进行分组合并，合并时，将每个value和初始值作为seq函数的参数，进行计算，返回的结果作为一个新的kv对，然后再将结果按照key进行合并，最后将每个分组的value传递给combine函数进行计算（先将前两个value进行计算，将返回结果和下一个value传给combine函数，以此类推），将key与计算结果作为一个新的kv对输出。
- 参数描述：
（1）zeroValue：给每一个分区中的每一个key一个初始值；
（2）seqOp：函数用于在每一个分区中用初始值逐步迭代value；
（3）combOp：函数用于合并每个分区中的结果。 - 需求：创建一个pairRDD，取出每个分区相同key对应值的最大值，然后相加
- 需求分析
图1-aggregate案例分析
（1）创建一个pairRDD
scala> val rdd = sc.parallelize(List(("a",3),("a",2),("c",4),("b",3),("c",6),("c",8)),2)
rdd: org.apache.spark.rdd.RDD[(String, Int)] =
ParallelCollectionRDD[0] at parallelize at <console>:24
（2）取出每个分区相同key对应值的最大值，然后相加
scala> val agg = rdd.aggregateByKey(0)(math.max(_,_),_+_)
agg: org.apache.spark.rdd.RDD[(String, Int)] =
ShuffledRDD[1] at aggregateByKey at <console>:26
（3）打印结果
scala> agg.collect()
res0: Array[(String, Int)] = Array((b,3), (a,3), (c,12))