spark算子

最新推荐文章于 2025-03-03 00:27:35 发布
最新推荐文章于 2025-03-03 00:27:35 发布
阅读量357 收藏
点赞数
分类专栏： spark 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45150724/article/details/115556499
版权
本文详细介绍了Apache Spark中Key-Value类型RDD的主要操作，包括reduceByKey、groupByKey、combineByKey、aggregateByKey等，并通过实例展示了这些操作的具体应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

Key-Value类型

reduceByKey()按照K聚合V

1）函数签名：
def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
2）功能说明：该操作可以将RDD[K,V]中的元素按照相同的K对V进行聚合。其存在多种重载形式，还可以设置新RDD的分区数。
3）需求说明：统计单词出现次数

可以发现在分区内就进行了聚合操作。然后分区间进行分组，就是会进行一个shuffle，然后再进行对应的累加。
在这里插入图片描述

object KeyValue02_reduceByKey {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd = sc.makeRDD(List(("a",1),("b",5),("a",5),("b",2)))

        //3.2 计算相同key对应值的相加结果
        val reduce: RDD[(String, Int)] = rdd.reduceByKey((v1,v2) => v1+v2)

        //3.3 打印结果
        reduce.collect().foreach(println)

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

groupByKey()按照K重新分组

功能说明

groupByKey对每个key进行操作，但只生成一个seq，并不进行聚合，也就是直接进行shuffle。

该操作可以指定分区器或者分区数（默认使用HashPartitioner）

在这里插入图片描述

object KeyValue03_groupByKey {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd = sc.makeRDD(List(("a",1),("b",5),("a",5),("b",2)))

        //3.2 将相同key对应值聚合到一个Seq中
        val group: RDD[(String, Iterable[Int])] = rdd.groupByKey()
        
        //3.3 打印结果
        group.collect().foreach(println)
        
        //3.4 计算相同key对应值的相加结果
        group.map(t=>(t._1,t._2.sum)).collect().foreach(println)

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

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()方法将各个分区的结果进行合并。

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

每个分区内

也就是，每个key值对应的累加器的初始值。初始值什么意思?就是每个分区第一次执行这个key，就是只执行一次。(一个分区中的一个key，初始化一次)

(acc: (Int, Int), v) => (acc._1 + v,acc._2 + 1)
第一个acc是之前累加过的，(累加的值，累加的个数)；
v是同一个key的值，因为是一个一个的累加，直接acc中对应的值加上v这个值。因为个数是1，所以直接用acc累加的个数加上1，就是累加过后的数目。

不同分区间

(acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
表示的是每个分区的数据进行相加，也就是不同的分区之间的同一个key的数据进行相加。值进行相加，次数进行相加。

在这里插入图片描述

代码实现

object KeyValue06_combineByKey {

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

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

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

        //3.1 创建第一个RDD
        val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93), ("a", 95), ("b", 98))
        val input: RDD[(String, Int)] = sc.makeRDD(list, 2)

        //3.2 将相同key对应的值相加，同时记录该key出现的次数，放入一个二元组
        val combineRdd: RDD[(String, (Int, Int))] = input.combineByKey(
       (_, 1), //就是(值,1)，每个分区某个key对应的初始值，这里就是转换结构的关键。
       (acc: (Int, Int), v) => (acc._1 + v,acc._2 + 1),
       (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
        )

        //3.3 打印合并后的结果
        combineRdd.collect().foreach(println)

        //3.4 计算平均值
        combineRdd.map {
            case (key, value) => {
                (key, value._1 / value._2.toDouble)
            }
        }.collect().foreach(println)

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

aggregateByKey()按照K处理分区内和分区间逻辑

需求:每个分区中的最大值进行累加。
在这里插入图片描述

在这里插入图片描述

object KeyValue04_aggregateByKey {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(("a", 3), ("a", 2), ("c", 4), ("b", 3), ("c", 6), ("c", 8)), 2)

        //3.2 取出每个分区相同key对应值的最大值，然后相加
//这里的0是初始值。
        rdd.aggregateByKey(0)(math.max(_, _), _ + _).collect().foreach(println)

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

foldByKey()分区内和分区间相同的aggregateByKey()

在这里插入图片描述

object KeyValue05_foldByKey {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val list: List[(String, Int)] = List(("a",1),("a",1),("a",1),("b",1),("b",1),("b",1),("b",1),("a",1))
        val rdd = sc.makeRDD(list,2)

        //3.2 求wordcount
        //rdd.aggregateByKey(0)(_+_,_+_).collect().foreach(println)
        //因为分区间和分区内的逻辑相同，所以只有一个位置即可。
        
        rdd.foldByKey(0)(_+_).collect().foreach(println)

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

sortByKey()按照K进行排序

1）函数签名：
def sortByKey(
ascending: Boolean = true, // 默认，升序
numPartitions: Int = self.partitions.length) : RDD[(K, V)]
2）功能说明
在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
3）需求说明：创建一个pairRDD，按照key的正序和倒序进行排序。

在这里插入图片描述

object KeyValue07_sortByKey {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd: RDD[(Int, String)] = sc.makeRDD(Array((3,"aa"),(6,"cc"),(2,"bb"),(1,"dd")))

        //3.2 按照key的正序（默认顺序）
        rdd.sortByKey(true).collect().foreach(println)

        //3.3 按照key的倒序
        rdd.sortByKey(false).collect().foreach(println)

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

mapValues()只对V进行操作

1）函数签名：def mapValues[U](f: V => U): RDD[(K, U)]
2）功能说明：针对于(K,V)形式的类型只对V进行操作
3）需求说明：创建一个pairRDD，并将value添加字符串"|||"

在这里插入图片描述

object KeyValue08_mapValues {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (1, "d"), (2, "b"), (3, "c")))

        //3.2 对value添加字符串"|||"
        rdd.mapValues(_ + "|||").collect().foreach(println)

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

join()连接

1）函数签名：
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]
def join[W](other: RDD[(K, W)], numPartitions: Int): RDD[(K, (V, W))]
2）功能说明
在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
3）需求说明：创建两个pairRDD，并将key相同的数据聚合到一个元组。

从这个图中可以看出，分区1中key1有v1，v2。分区2中key1有v5，v6。显然在key1的这种情况下，有4中组合。
在这里插入图片描述

object KeyValue09_join {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))

        //3.2 创建第二个pairRDD
        val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (4, 6)))

        //3.3 join操作并打印结果
        rdd.join(rdd1).collect().foreach(println)

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

cogroup()类似全连接，但是在同一个RDD中对key聚合

1）函数签名：def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
2）功能说明
在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
操作两个RDD中的KV元素，每个RDD中相同key中的元素分别聚合成一个集合。
3）需求说明：创建两个pairRDD，并将key相同的数据聚合到一个迭代器。

类似于join那种full join，没有join上的写null。这不过这里啥也没有。
在这里插入图片描述

object KeyValue10_cogroup {

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

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

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

        //3具体业务逻辑
        //3.1 创建第一个RDD
        val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1,"a"),(2,"b"),(3,"c")))

        //3.2 创建第二个RDD
        val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1,4),(2,5),(4,6)))

        //3.3 cogroup两个RDD并打印结果
// (1,(CompactBuffer(a),CompactBuffer(4)))
// (2,(CompactBuffer(b),CompactBuffer(5)))
// (3,(CompactBuffer(c),CompactBuffer()))
// (4,(CompactBuffer(),CompactBuffer(6)))
        rdd.cogroup(rdd1).collect().foreach(println)

        //4.关闭连接
        sc.stop()
    }
}
Spark 算子
TT15751097576的博客
10-07 545
Spark大数据计算框架 Spark（火花）出现不全是代替Map Reduce，里面有批处理（Spark运行在内存中，Map Reduce运行在硬盘中，根据自身情况选择适应的开发环境（比如：机器的数量，配置，资金等等）） 了解Hadoop发展历史：2011年发布1.0版本，2012年发布稳定版，2013年发布2.X版本（里面出现了Yarn，得以重用） 2012年版本中 MR的缺点： mr基于数据集...
Spark算子
JasonChen3318的博客
05-07 623
1.parallelize 1.解释 - 并行集合的创建（RDD） 使用已经存在的迭代器或者集合通过调用spark驱动程序提供的parallelize函数来创建并行集合 - 并行集合被创建用来在分布式集群上并行计算的。 2.例子 data = [1, 2, 3, 4, 5] distData = sc.parallelize(data) 一旦创建RDD，RDD，就可以在集群上并行的去被操作。我...
Spark的算子的分类
kgars1的博客
10-16 1784
从大方向来说，Spark 算子大致可以分为以下两类:      1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。 　　　Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。      2）Action 行动算子：
Spark核心之02：RDD、算子分类、常用算子
最新发布
我的博客
03-03 1166
在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置 ，在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD。在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD。返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成。
【二十一】Spark常用算子
Sid小杰的博客
08-15 667
转自 Spark的算子的分类 从大方向来说，Spark 算子大致可以分为以下两类:      1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。 　　　　　Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。      2...
Spark算子系列文章
王文强的博客
06-29 1133
Spark算子：RDD基本转换操作(1)–map、flagMap、distinct Spark算子：RDD创建操作 Spark算子：RDD基本转换操作(2)–coalesce、repartition Spark算子：RDD基本转换操作(3)–randomSplit、glom Spark算子：RDD基本转换操作(4)–union、intersection、subtract
Java Spark算子：sample
01-07
import org.apache.spark.... * sample(withReplacement,fraction,seed) 算子 * 对RDD中的数据进行随机采样，会有误差。 * 第一个参数：boolean类型，表示产生的样本是否可以重复：false不重复，也就是不放回的取；t
25个经典Spark算子的JAVA实现
08-16
根据给定文件的信息，本文将详细介绍25个经典Spark算子的Java实现，并结合详细的注释及JUnit测试结果，帮助读者更好地理解Spark算子的工作原理及其应用方式。 ### Spark算子简介 在Apache Spark框架中，算子是用于...
经典Spark算子的JAVA实现.zip
07-02
本资料“经典Spark算子的JAVA实现.zip”提供了25个核心Spark算子的Java实现，这些实现已经过Junit测试，确保了代码的正确性和可靠性。以下是对这些算子的详细介绍： 1. **map()**: 这是Spark中最基本的转换操作，它...
Spark算子综合案例 - Scala篇
weixin_51439828的博客
04-22 1503
补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。//2.切分压平、直接好友拼接加入集合、遍历、间接好友拼接、返回集合。//4判断每一行里如果为直接好友将其次数设为0，如果不是+1。//5过滤掉次数为0的剩下的就是间接好友及其次数。区域内进行代码补充，完成统计间接好友的数量的程序。else ("直接好友", 0)请仔细阅读右侧代码，根据方法内的提示，在。知识完成 " 好友推荐 " 的程序。数据说明（第二行为例）： 这个人叫。在间接好友关系中出现的次数为。
头歌-Spark算子 - JAVA版本
bzzb52的博客
06-21 948
【代码】头歌-Spark算子 - JAVA版本。
Spark的算子
xieyichun_的博客
10-31 1824
分享了spark中的算子
spark的算子
diskindom的博客
11-23 1170
Spark中的单Value算子是指对一个RDD中的每个元素进行操作，并返回一个新的RDD。这些单Value算子能够对RDD中的每个元素进行处理，并返回一个新的RDD，可以用于各种数据转换、过滤、去重等操作。
Spark32个常用算子总结
热门推荐
Fortuna_i的博客
08-09 4万+
官方文档上列举共有32种常见算子，包括Transformation的20种操作和Action的12种操作。 （注：以下截图为windows下运行结果） Transformation： 1.map map的输入变换函数应用于RDD中所有元素，而mapPartitions应用于所有分区。区别于mapPartitions主要在于调用粒度不同。如parallelize（1 to 10， 3），ma...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值