spark(三)

本节课接着上节课的继续学习了Key-Value类型中的sortByKey、join、leftOuterJoin、cogroup,新学习了RDD行动算子,其中包括reduce、collect、foreach、count、first、take、takeOrdered、aggregate、fold、countByKey、save相关算子等;还学习了累加器跟广播变量

Key-Value类型

sortByKey

复制代码
def sortByKey(ascending: Boolean = true, numPartitions: Int = self.partitions.length)
 : RDD[(K, V)]

按照 key 对 RDD 进行排序

join

复制代码
def join[W](other: RDD[(K, W)]): RDD[(K, (V, W))]

对两个类型为 (K, V) 和 (K, W) 的 RDD 进行连接操作

leftOuterJoin

复制代码
def leftOuterJoin[W](other: RDD[(K, W)]): RDD[(K, (V, Option[W]))]

类似于 SQL 中的左外连接

cogroup

复制代码
def cogroup[W](other: RDD[(K, W)]): RDD[(K, (Iterable[V], Iterable[W]))]

对两个类型为 (K, V) 和 (K, W) 的 RDD 进行分组操作


RDD行动算子

行动算子就是会触发action的算子,触发action的含义就是真正的计算数据。

先添加如下:

1.reduce

复制代码
def reduce(f: (T, T) => T): T

对 RDD 元素进行聚集操作,先聚合分区内数据,再聚合分区间数据

2. collect

复制代码
def collect(): Array[T]

将 RDD 所有元素以数组形式返回至驱动程序

3. foreach

复制代码
def foreach(f: T => Unit): Unit = withScope {

 val cleanF = sc.clean(f)

 sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))

}

分布式遍历 RDD 元素并调用指定函数

4. count

复制代码
def count(): Long

返回 RDD 中元素的数量

5. first

复制代码
def first(): T

返回 RDD 的第一个元素

6.take

复制代码
def take(num: Int): Array[T]

返回 RDD 前n个元素组成的数组

7. takeOrdered

复制代码
def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]

返回 RDD 排序后的前n个元素组成的数组

8) aggregate

复制代码
def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

分区内和分区间使用初始值进行数据聚合

9. fold

复制代码
def fold(zeroValue: T)(op: (T, T) => T): T

是aggregate的简化操作

10. countByKey

复制代码
def countByKey(): Map[K, Long]

统计 RDD 中每种key的数量

11.save 相关算子

复制代码
def saveAsTextFile(path: String): Unit

def saveAsObjectFile(path: String): Unit

def saveAsSequenceFile(

 path: String,

 codec: Option[Class[_ <: CompressionCodec]] = None): Unit //了解即可

将 RDD 数据保存为不同格式的文件,如文本文件、对象文件等

累加器

把 Executor 端变量信息聚合到 Driver 端

复制代码
 // 累加器示例
    val rdd = sparkContext.makeRDD(List(1, 2, 3, 4, 5))
    // 声明累加器
    var sum = sparkContext.longAccumulator("sum")
    rdd.foreach(
      num => {
        // 使用累加器
        sum.add(num)
      }
    )
    // 获取累加器的值
    println("sum = " + sum.value)

    // 自定义累加器实现 wordcount
    // 创建自定义累加器
    class WordCountAccumulator extends AccumulatorV2[String, mutable.Map[String, Long]] {
      var map: mutable.Map[String, Long] = mutable.Map()

      override def isZero: Boolean = map.isEmpty

      override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] = new WordCountAccumulator

      override def reset(): Unit = map.clear()

      override def add(v: String): Unit = {
        map(v) = map.getOrElse(v, 0L) + 1L
      }

      override def merge(other: AccumulatorV2[String, mutable.Map[String, Long]]): Unit = {
        val map1 = map
        val map2 = other.value
        map = map1.foldLeft(map2)(
          (innerMap, kv) => {
            innerMap(kv._1) = innerMap.getOrElse(kv._1, 0L) + kv._2
            innerMap
          }
        )
      }

      override def value: mutable.Map[String, Long] = map
    }

    // 调用自定义累加器
    val rddWords = sparkContext.makeRDD(
      List("spark", "scala", "spark hadoop", "hadoop")
    )
    val acc = new WordCountAccumulator
    sparkContext.register(acc)

    rddWords.flatMap(_.split(" ")).foreach(
      word => acc.add(word)
    )
    println(acc.value)
    println("--------------------累加器---------------------")

广播变量

广播变量用于高效分发较大的只读对象到所有工作节点

相关推荐
墨林陌15 小时前
AI 热点日报(2026-11-16):黄仁勋或重返英伟达,华为发具身世界模型,ChatGPT Wallet打通支付
大数据
starzy199015 小时前
Structured Streaming 结构化流概述:把流数据当作一张无限增长的表
大数据·spark
wuyk55516 小时前
Spider-第12讲-asyncio异步并发爬取
大数据·爬虫·elasticsearch·搜索引擎
筑梦之人16 小时前
Elasticsearch 9.x 从入门到精通(4/7):聚合分析与文本分析
大数据·elasticsearch·jenkins
数字新视界1 天前
信创动环监控在机房环境管理中的智能化应用与实践分析
大数据·人工智能·物联网·信息与通信·动环监控系统
大大大大晴天1 天前
数仓分层架构设计:ODS、DWD、DWS、ADS、DIM 如何各司其职
大数据
Funlang1 天前
在 Windows 95 上跑 Fun
windows
东鸿电子Eastron2 天前
工厂节能降本落地指南:从精准能源计量搭建数字化管理基础
大数据·人工智能·能源·智能电表·能耗管理
吾AI科技2 天前
基于Tez引擎的 Hive SQL 性能优化 —— 为什么脚本运行越来越慢
大数据·hive·性能优化·tez
ö Constancy2 天前
一台电脑的硬件组成与作用:按功能分类详解(Windows 与 Linux 视角)
linux·windows·电脑