combineByKey()转换结构后分区内和分区间操作

1）函数签名：

def combineByKey[C](

createCombiner: V => C,

mergeValue: (C, V) => C,

mergeCombiners: (C, C) =>C): RDD[(K, C)]

（1）createCombiner（转换数据的结构）: combineByKey() 会遍历分区中的所有元素，因此每个元素的键要么还没有遇到过，要么就和之前的某个元素的键相同。如果这是一个新的元素，combineByKey()会使用一个叫作createCombiner()的函数来创建那个键对应的累加器的初始值

（2）mergeValue（分区内）: 如果这是一个在处理当前分区之前已经遇到的键，它会使用mergeValue()方法将该键的累加器对应的当前值与这个新的值进行合并

（3）mergeCombiners（分区间）: 由于每个分区都是独立处理的，因此对于同一个键可以有多个累加器。如果有两个或者更多的分区都有对应同一个键的累加器，就需要使用用户提供的mergeCombiners()方法将各个分区的结果进行合并。

2）功能说明

针对相同K，将V合并成一个集合。

3）需求说明：创建一个pairRDD，根据key计算每种key的平均值。（先计算每个key出现的次数以及可以对应值的总和，再相除得到结果）

4）需求分析：

代码实现：

package com.huc.Spark.KeyAndValue

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Test06_combineByKey {
  def main(args: Array[String]): Unit = {

    //1.创建SparkConf并设置App名称
    val conf: SparkConf = new SparkConf().setAppName("SparkCore").setMaster("local[*]")

    //2.创建SparkContext，该对象是提交Spark App的入口
    val sc: SparkContext = new SparkContext(conf)

    //3.使用Scala进行spark编程
    val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98))
    val rdd: RDD[(String, Int)] = sc.makeRDD(list, 2)

    // 对上面进行wc的聚合，元素类型变成（"单词"，（"总次数"，10））
    // 算子需要填写3个匿名函数
    // 1.表示对初始值进行转换，选取第一个元素作为初始值，对其进行结构的转换
    // 2.表示分区内聚合的逻辑，因为初始值已经发生了结构的转换，
    // 所以里面的两个元素表示（初始值，元素值）=>（结果值[类型和初始值保持一致]）
    // 3.表示分区间的聚合 由于分区内已经对结果的类型发生了转变，所以两个参数的类型都是转化后的类型
    val value: RDD[(String, (String, Int))] = rdd.combineByKey(i => ("总次数", i),
      (res: (String, Int), elem) => (res._1, res._2 + elem),
      (combine1: (String, Int), combine2: (String, Int)) => (combine1._1, combine2._2 + combine1._2))

    println(value.collect().mkString(","))

    // 需求：求出相同的key的平均值
    val value1: RDD[(String, Int)] = sc.makeRDD(list, 2)

    val value2: RDD[(String, (Int, Int))] = value1.combineByKey(
      // 求平均值  需要求value的和以及value的次数 (和，次数)
      i => (i, 1),
      // 进行分区内的聚合，将相同的key在同一个分区内进行聚合
      (res: (Int, Int), elem: Int) => (res._1 + elem, res._2 + 1),
      // 再进行分区间的聚合，相同的key进行shuffle，把所有的和以及所有的次数加起来
      (c1: (Int, Int), c2: (Int, Int)) => (c1._1 + c2._1, c2._2 + c1._2)
    )
    println(value2.collect().mkString(","))

    val tuple1: RDD[(String, Int)] = value2.map(tuple => (tuple._1, tuple._2._1 / tuple._2._2))

    println(tuple1.collect().mkString(","))


    //4.关闭连接
    sc.stop()

  }
}