Spark-CombineByKey函数

最新推荐文章于 2022-10-31 20:25:11 发布

eddieVim

最新推荐文章于 2022-10-31 20:25:11 发布

阅读量152

点赞数

分类专栏： Spark

本文链接：https://blog.csdn.net/weixin_44129784/article/details/113441660

版权

Spark 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

该博客演示了如何使用Spark的combineByKey函数来计算RDD[(String, Int)]类型的键值对数据的sum、count、max、min和avg。通过对Value值应用不同的操作，例如加法、最大值和最小值比较，以及平均值计算，展示了如何实现这些聚合操作。

摘要由CSDN通过智能技术生成

combineByKey

CombineByKey这一函数过程就是根据Key值，将Value值进行合并的过程。

参数解释

def combineByKey[C](
      createCombiner: V => C,
      mergeValue: (C, V) => C,
      mergeCombiners: (C, C) => C): RDD[(K, C)] = {
}

createCombiner: V => C：如何处理第一个Value

mergeValue: (C, V) => C：如何处理Combine与后面来的Value之间的运算关系

mergeCombiners: (C, C) => C：如何处理Combine与Combine之间的运算关系

求（sum、count、max、min、avg）

package pro.eddievim.spark

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

object ReduceByKeyDemo {
  def main(args: Array[String]): Unit = {
    val sc: SparkContext = new SparkContext(new SparkConf().setMaster("local").setAppName("reduce-by-key"))

    sc.setLogLevel("ERROR")

    val data: RDD[(String, Int)] = sc.parallelize(List(
      ("eddie", 10),
      ("july", 80),
      ("july", 12),
      ("eddie", 1024),
      ("eddie", 7),
      ("july", 12),
      ("june", 12),
      ("june", 62)
    ))

    println("--sum--count--max--min--avg--")
    println("---sum---")
    data.combineByKey(
      a=>a,
      (a:Int, b:Int) => a + b,
      (a:Int, b:Int) => a + b
    ).foreach(println)

    println("---count---")
    data.mapValues(_ => 1).combineByKey(
      a=>a,
      (a:Int, b:Int) => a + b,
      (a:Int, b:Int) => a + b
    ).foreach(println)

    println("---max---")
    data.combineByKey(
      a=>a,
      (a:Int, b:Int) => Math.max(a, b),
      (a:Int, b:Int) => Math.max(a, b)
    ).foreach(println)

    println("---min---")
    data.combineByKey(
      a=>a,
      (a:Int, b:Int) => Math.min(a, b),
      (a:Int, b:Int) => Math.min(a, b)
    ).foreach(println)

    println("---avg---")

    data.mapValues((_, 1)).combineByKey(
      a => a,
      (a: (Int, Int), b: (Int, Int)) => (a._1 + b._1, a._2 + b._2),
      (a: (Int, Int), b: (Int, Int)) => (a._1 + b._1, a._2 + b._2)
    ).mapValues(a=>a._1 * 1.0 / a._2).foreach(println)
  }
}