Spark Core之RDD键值对算子

最新推荐文章于 2024-07-19 16:04:56 发布
最新推荐文章于 2024-07-19 16:04:56 发布
阅读量202 收藏
点赞数
文章标签： spark 大数据 kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46433375/article/details/126565985
版权
本文详细介绍了Spark Core中的键值对算子，包括转换算子和行动算子。转换算子如groupByKey、reduceByKey、aggregateByKey、combineByKey、sortByKey等，用于数据的分组、聚合和排序；行动算子如countByKey和saveAsSequenceFile，用于统计键的数量和将数据持久化到HDFS。这些算子在大数据处理中发挥着重要作用。
摘要由CSDN通过智能技术生成

一、 转换算子

1、groupByKey算子

def groupByKey(): RDD[(K, Iterable[V])]
def groupByKey(numPartitions: Int): RDD[(K, Iterable[V])]
def groupByKey(partitioner: Partitioner): RDD[(K, Iterable[V])]
将数据源的数据根据 key 对 value 进行分组，分组后返回一个新的函数

object GroupByKeyOperator {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("groupByKey").setMaster("local")
    val sc = new SparkContext(conf)
    var rdd = sc.makeRDD(List("hadoop", "flink", "flink", "kafka", "flink"))
    val rdd2 = rdd.flatMap(f => {
      f.split(",")
    })
    val rdd3 = rdd2.map(word => {
      (word, 1)
    })
    val rdd4 = rdd3.groupByKey()
    rdd4.foreach(println(_))
  }
}

在这里插入图片描述

2、reduceByKey算子

def reduceByKey(func: (V, V) => V): RDD[(K, V)]
def reduceByKey(func: (V, V) => V, numPartitions: Int): RDD[(K, V)]
可以将数据按照相同的Key 对Value 进行聚合

object ReduceByKeyOperator {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("reduceByKey").setMaster("local")
    val sc = new SparkContext(conf)

    val rdd = sc.makeRDD(List("hadoop", "flink", "flink", "hadoop", "spark", "kafka"))
    val rdd2 = rdd.flatMap(f => {
      f.split(",")
    })
    val rdd3 = rdd2.map(word => {
      (word, 1)
    })
    val rdd4 = rdd3.reduceByKey((a, b) => {
      a + b
    })
    rdd4.foreach(println(_))
  }
}

在这里插入图片描述

3、aggregateByKey算子

def aggregateByKey[U: ClassTag](zeroValue: U)
(
seqOp: (U, V) => U,
combOp: (U, U) => U
): RDD[(K, U)]
将数据根据不同的规则进行分区内计算和分区间计算
aggregateByKey 算子是函数柯里化，存在两个参数列表

  1. 第一个参数列表中的参数表示初始值
  2. 第二个参数列表中含有两个参数
    2.1 第一个参数表示分区内的计算规则
    2.2 第二个参数表示分区间的计算规则
object AggregateByKeyOperator {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("aggregateByKey").setMaster("local")
    val sc = new SparkContext(conf)

    val rdd = sc.makeRDD(List("hadoop", "flink", "flink", "hadoop", "spark", "kafka"))
    val rdd2 = rdd.flatMap(f => {
      f.split(",")
    })
    val rdd3 = rdd2.map(word => {
      (word, 1)
    })
    val rdd4 = rdd3.aggregateByKey(0)(
      (a, b) => {
        a + b
      },
      (a, b) => {
        a + b
      }
    )
    rdd4.foreach(println(_))
  }
}

在这里插入图片描述

4、combineByKey算子

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

最通用的对key-value 型 rdd 进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。

object CombineByKeyOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("combineByKey")
    val sc = new SparkContext(sparkConf)

    val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",60),("zs",70),("zs",80),("ls",66),("ls",60),("ls",77)))
    val rdd2 = rdd.combineByKey(
      (a: Int) => {
        a
      },
      (a: Int, b: Int) => {
        a + b
      },
      (a: Int, b: Int) => {
        a + b
      }
    )
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

5、sortByKey算子

def sortByKey(
ascending: Boolean = true,
numPartitions: Int = self.partitions.length
)
: RDD[(K, V)]
按照key值对RDD进行排序，返回一个排序完成RDD，同时也可以分组

object SortByKeyOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("kv")
    val sc = new SparkContext(sparkConf)

    val rdd:RDD[(String,Int)] = sc.makeRDD(Array(("zs",20),("ls",30),("ww",40),("zl",40),("zs",40)))
    val rdd2 = rdd.sortByKey()
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

6、join算子

def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]
将两个键值对类型RDD按照相同的key值将不同rdd的value数据整合一下
(K,V） (K,W)===>(K,(V,W))
而且只会保留两个RDD中key值相同的数据，key值不相同的数据舍弃
传入的另外一个键值对类型的RDD有要求，key值必须和当前RDD的key值类型一致，value类型可以不一致

object JoinOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("join")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2: RDD[(String, String)] = sc.makeRDD(Array(("ls", "女"), ("zs", "男"), ("zs", "女"), ("ww", "男"), ("wb", "男")))
    val rdd3 = rdd.join(rdd2)
    rdd3.foreach(println(_))
  }
}

在这里插入图片描述

7、leftOuterJoin算子

和join类似，只不过保留左边RDD的所有数据，括号里面的RDD只保留匹配数据 （K，（V，Option[W]））

object LeftOuterJoinOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("leftOuterJoin")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2: RDD[(String, String)] = sc.makeRDD(Array(("ls", "女"), ("zs", "男"), ("zs", "女"), ("ww", "男"), ("wb", "男")))
    val rdd3 = rdd.leftOuterJoin(rdd2)
    rdd3.foreach(println(_))
  }
}

8、rightOuterJoin算子

和join类似，只不过保留右边RDD的所有数据，左边的RDD只保留匹配（key来匹配）数据 （K，（Option[V]，W））

object RightOuterJoinOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("rightOuterJoin")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2: RDD[(String, String)] = sc.makeRDD(Array(("ls", "女"), ("zs", "男"), ("zs", "女"), ("ww", "男"), ("wb", "男")))
    val rdd3 = rdd.rightOuterJoin(rdd2)
    rdd3.foreach(println(_))
  }
}

在这里插入图片描述

9、cogroup算子

def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]
将两个键值对类型的RDD按照key值聚合value。将每一个RDD的key值相同的value数据聚合成为一个迭代器Iterable[V]
最终返回如下的一个RDD
RDD【（key，（Iterable[V]，Iterable[W]））】

object CoGroupOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("cogroup")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2: RDD[(String, String)] = sc.makeRDD(Array(("ls", "女"), ("zs", "男"), ("zs", "女"), ("ww", "男"), ("wb", "男")))
    val rdd3 = rdd.cogroup(rdd2)
    rdd3.foreach(println(_))
  }
}

在这里插入图片描述

10、subtractByKey算子

删除前面RDD中与括号传入的RDDkey值相同的元素，返回的是前者RDD删除完成的数据

object SubTractByKeyOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("subTractByKey")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2: RDD[(String, String)] = sc.makeRDD(Array(("ls", "女"), ("zs", "男"), ("zs", "女"), ("ww", "男"), ("wb", "男")))
    val rdd3 = rdd.subtractByKey(rdd2)
    rdd3.foreach(println(_))
  }
}

在这里插入图片描述

11、keys算子

将键值对类型RDD中的所有key值取出来形成一个新的RDD

object KeysOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("Keys")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2 = rdd.keys
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

12、values算子

将键值对类型RDD中的所有value值取出来形成一个新的RDD

object ValuesOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("Values")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2 = rdd.values
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

13、mapValues算子

对键值对RDD中所有values数据应用一个func函数，代表对每一个value数据做一个操作 返回一个新的RDD
func (T)=>U
RDD[(key,U)]

object MapValuesOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("MapValues")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 20), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2 = rdd.mapValues(a => {a + 1})
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

二、 行动算子

1、 countByKey算子

def countByKey(): Map[K, Long]
统计每种 key 的个数

object CountByKeyOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("CountByKey")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 40), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    val rdd2 = rdd.countByValue()
    rdd2.foreach(println(_))
  }
}

在这里插入图片描述

2、 saveAsSequenceFile算子

saveAsSequenceFile()：rdd有几个分区在HDFS上保存几个文件

object saveAsSequenceFileOperator {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setMaster("local").setAppName("CountByKey")
    val sc = new SparkContext(sparkConf)

    val rdd: RDD[(String, Int)] = sc.makeRDD(Array(("zs", 40), ("ls", 30), ("ww", 40), ("zl", 40), ("zs", 40)))
    rdd.saveAsSequenceFile("hdfs://node1:9000/b")
  }
}
翻斗花园牛爷爷..
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spark Core中RDD数值型算子
派大星的博客
08-23 347
转换算子和行动算子
【SparkCore篇03】RDD行动算子1
08-04
例如，我们可以创建一个键值对RDD，通过`reduce`计算所有键的组合以及值的总和。 2. `collect`算子： `collect`算子用于将RDD中的所有元素转换为数组并返回。这通常用于在驱动程序中查看或处理数据。例如，我们...
Spark取出(Key,Value)型数据中Value值为前n条数据
热门推荐
dai451954706的专栏
09-26 1万+
Spark对(Key,Value)型数据进行排序，并取出Value值为前n的数据
Spark RDD 按Key保存到不同文件
王佩的CSDN博客
11-02 4756
基本需求 将Keyed RDD[(Key,Value)]按Key保存到不同文件。 测试数据 数据格式：id,studentId,language,math,english,classId,departmentId 1,111,68,69,90,Class1,Economy 2,112,73,80,96,Class1,Economy 3,113,90,74,75,Class1,Economy 4...
Spark RDD之Key-Value类型操作详解
qq_43193797的博客
04-12 7451
partitionBy案例 1. 作用：对pairRDD进行分区操作，如果原有的partionRDD和现有的partionRDD是一致的话就不进行分区，否则会生成ShuffleRDD，即会产生shuffle过程。 2. 需求：创建一个4个分区的RDD，对其重新分区 （1）创建一个RDD scala> val rdd = sc.parallelize(Array((1,"aaa"...
Spark RDD Key-Value基本转换和动作运算实例
叶小刀
08-21 3637
创建Key-Value RDD  kvRDD1 = sc.parallelize([(3,6),(6,9),(3,4),(5,6),(1,2)]) 转换：取key和value >>> kvRDD1.collect() [(3, 6), (6, 9), (3, 4), (5, 6), (1, 2)] >>> kvRDD1.keys().collect() [...
SparkCore之RDD算子transformation
mcdull213的博客
05-01 137
1、map vs mapPartition map：作用于每一个元素，迭代次数==>元素数 mapPartition：作用于每一个分区，迭代次数==>分区数 ==>因此，对于数据库创建、对象创建等操作，优选mapPartition mapPartitionWithIndex：返回分区index val rdd = sc.parallelize(List(1, 2, 3...
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
【SparkCore篇02】RDD转换算子1
08-04
SparkCore篇02主要介绍了RDD的一些基础转换算子，这些算子是Spark处理数据的核心工具。以下是关于这些算子的详细说明： 1. **map()**：map算子用于对RDD（Resilient Distributed Dataset）中的每个元素进行操作。它...
Spark学习笔记之Spark中的RDD的具体使用
08-25
本文通过详细的示例代码介绍了Spark学习笔记之Spark中的RDD的具体使用，涵盖了RDD的概念、特点、在Spark中的作用、 Spark中的名词解释、创建RDD的两种方式、IDEA开发Spark等多个方面，对大家的学习或者工作具有一定...
Spark核心之弹性分布式数据集RDD
02-24
1.1什么是RDD(1)RDD...1.2RDD的属性打开Spark源代码，源码的注释中对RDD的描述如下图。(1)Alistofpartitions一系列的分区(2)Afunctionforcomputingeachsplit每个函数作用于每一个分区(3)Alistofdepen
SparkCore RDD算子（看这一篇就够了~）
wanjialin的博客
12-13 1197
简述： Spark的算子分为转换算子（Transformation）和行动算子（Action）。 转换算子将RDD转换成新的RDD，或者将文件系统的数据转换成一个RDD，行动算子会形成一个job。 转换算子（很重要！）： 转换算子分为：Value类型，双Value类型和Key-Value类型。 Value类型 1、map 函数签名：def map[U: ClassTag](f:T => U): RDD[U] 功能说明：参数f是一个函数，它可以接收一个参数。当某个RDD执行map方法时，会遍历该RDD中
sparkCore之sparkRDD常用算子
墨殇
06-19 716
前言： sparkRDD的操作，从宏观上分为：Transformation和Action，但是具体的还以分为：输入算子、变换算子、缓存算子，以及行动算子。 官网地址： https://spark.apache.org/docs/latest/rdd-programming-guide.html#resilient-distributed-datasets-rdds
spark中的join算子讲解
yrsg666的博客
08-27 2245
https://blog.csdn.net/Lu_Xiao_Yue/article/details/83926650
Spark 中几个 join 算子
weixin_33676492的博客
05-16 571
Spark 中和 join 相关的算子有这几个：join、fullOuterJoin、leftOuterJoin、rightOuterJoin 这几种 join 算子和 sql 中的 join 类似，join 相当于内连接，fullOuterJoin 相当于全连接，leftOuterJoin 相当于左连接，rightOuterJoin 相当于右连接。 分别解释下这几种连接在 sql 中的含义，sp...
Spark Streaming
2301_77836489的博客
07-19 257
Spark Streaming
java.sql.SQLException: Unknown system variable ‘query_cache_size‘【Pyspark】
weixin_51744807的博客
07-15 512
位置：E:\programfiles\anaconda\Lib\site-packages\pyspark\jars（这里根据各自的环境安排）根据该报错，发现网络上多数解决方都是基于java开发的解决方案，尝试过多种jar配置途径，都没办法解决该问题。首先产生该问题是没有配置合适的jar包，因此需要在本机的pyspark包中配置相关jar。后续发现时jar包有问题，通过参考其他文章思路，最终通过合适的jar包解决问题。的格式并提交到本地的mysql中，相关代码见文章末尾。的所以jar包一般用最新的即可。
spark shell
最新发布
m0_74934794的博客
07-19 106
2.1.1读取linux文件系统的文件创建RDD。2.1.2读取hdfs文件系统上的文件创建RDD。--需要保证每一个worker中都有该文件。--过滤数据,保留每行中含有hello的数据。2.2使用Parallelize创建RDD。2.3从其他的RDD中创建新的RDD。--对RDD中的数据进行过滤操作。--统计RDD中的数据记录表。2.1 读取文件创建RDD。--读取RDD的第一条数据。4.实现wordcount。1.进行shell命令行。3.对RDD进行操作。--读取中的N条数据。
从数据湖到湖仓一体：统一数据架构演进之路
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
07-17 1301
本文详细探讨了从数据湖到湖仓一体的演进过程及其在现代数据管理中的重要性。湖仓一体由Databricks于2020年提出，旨在融合数据湖和数据仓库的优势，通过无缝集成，实现数据存储和管理的统一架构。 湖仓一体的出现主要是为了降低成本和解决数据孤岛问题。传统的数据湖和数据仓库各自独立建设，导致重复投资和数据管理上的困难，而湖仓一体通过简化基础架构、提升数据存储弹性和质量，有效减少了这些问题。
spark里的RDD transform算子有多少个
05-26
Spark中的RDD Transform算子有很多，以下是一些常用的Transform算子： 1. map(func) 2. filter(func) 3. flatMap(func) 4. mapPartitions(func) 5. union(otherRDD) 6. distinct() 7. groupByKey() 8. reduceByKey...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值