通过例子学习spark rdd--Action函数

最新推荐文章于 2023-04-09 14:35:38 发布
最新推荐文章于 2023-04-09 14:35:38 发布
阅读量1k 收藏
点赞数
分类专栏： spark 大数据处理 文章标签： spark 函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zg_hover/article/details/78637457
版权

通过例子学习spark rdd–Action函数

action函数

Action函数会产生任务，并会把任务提交到spark集群中。
注意：这些函数一般的返回值都是Unit。

foreach

  • 功能说明
    在RDD的所有元素使用函数。

  • 函数原型

def foreach(f: T => Unit): Unit
  • 函数实现
 /**
   * Applies a function f to all elements of this RDD.
   */
  def foreach(f: T => Unit): Unit = withScope {
    // 清理闭包，使其准备好序列化并发送到任务
    val cleanF = sc.clean(f)
    // 提交任务到spark集群，并使用函数f处理RDD的每个分区的每个元素
    sc.runJob(this, (iter: Iterator[T]) => iter.foreach(cleanF))
  }
  • 使用例子

注意：若spark是集群模型，会看不到foreach的输出。

scala> val r1 = sc.parallelize(Array("a", "b", "c", "d"))
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[19] at parallelize at <console>:24

scala> r1.foreach(item => println("hello " + item))

若是在单机的spark上，可以看到以下效果：

scala> val r1 = sc.parallelize(Array("a", "b", "c", "d"))
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> r1.foreach(item => println("hello " + item))
[Stage 0:>                                                          (0 + 0) / 2]hello a
hello b
hello c
hello d

foreachPartition

  • 功能说明
    在RDD的每个分区上使用同一个处理函数。

  • 函数原型

def foreachPartition(f: Iterator[T] => Unit): Unit
  • 函数实现
 /**
   * Applies a function f to each partition of this RDD.
   */
  def foreachPartition(f: Iterator[T] => Unit): Unit = withScope {
    val cleanF = sc.clean(f)
    // 注意这里函数的参数是每个分区
    sc.runJob(this, (iter: Iterator[T]) => cleanF(iter))
  }
  • 使用例子

查看每个分区的数据量大小。

scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "h", "i"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> r1.foreachPartition(c=>println(c.length))
3
3
3

collect

  • 功能
    把RDD的所有元素都返回到本地的数组中。
    该函数可以用于打印RDD的内容，在调试的时候非常有用。但注意：若数据量太大，可能导致OOM。

  • 函数原型和实现
    def collect(): Array[T]
    def collect[U: ClassTag](f: PartialFunction[T, U]): RDD[U]

  • 函数实现

/**
   * Return an array that contains all of the elements in this RDD.
   *
   * @note this method should only be used if the resulting array is expected to be small, as
   * all the data is loaded into the driver's memory.
   */
  def collect(): Array[T] = withScope {
    val results = sc.runJob(this, (iter: Iterator[T]) => iter.toArray)
    Array.concat(results: _*)
  }
  • 使用举例
scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[4] at parallelize at <console>:24

scala> r1.foreachPartition(c=>println(c.length))
3
4
4

scala> r1.collect()
res23: Array[String] = Array(a, b, c, d, e, f, g, h, i, j, k)

subtract

  • 功能
    执行标准的集合相减操作：A-B。
    注意：在使用该函数时，要保证两个RDD的元素类型是相同的。

  • 函数原型

def subtract(other: RDD[T]): RDD[T]
def subtract(other: RDD[T], numPartitions: Int): RDD[T]
def subtract(other: RDD[T], p: Partitioner): RDD[T]
  • 使用举例
scala> val r1 = sc.parallelize(1 to 10, 3)
r1: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[23] at parallelize at <console>:24

scala> val r2 = sc.parallelize(5 to 15, 3)
r2: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[24] at parallelize at <console>:24

scala> r1.subtract(r2)
res21: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[28] at subtract at <console>:29

scala> r2.collect()
res26: Array[Int] = Array(5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> r1.collect()
res27: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> r3.collect()
res28: Array[Int] = Array(3, 1, 4, 2)

reduce

  • 函数功能
    使用指定的交换和关联二元运算符来reduce此RDD的元素。

  • 函数原型

def reduce(f: (T, T) => T): T
  • 使用举例
scala> val a = sc.parallelize(1 to 100, 3)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[33] at parallelize at <console>:24

scala> a.reduce(_+_)
res29: Int = 5050

// 和map结合使用
scala> a.map(_*2).reduce(_+_)
res30: Int = 10100

treeReduce

  • 函数功能
    和reduce函数的功能相似，不同的是该函数通过tree的方式对结果进行聚合。

  • 函数原型

def  treeReduce(f: (T, T) ⇒ T, depth: Int = 2): T
  • 使用举例
val z = sc.parallelize(List(1,2,3,4,5,6), 2)
z.treeReduce(_+_)
res49: Int = 21

fold

  • 函数功能
    聚合每个分区的值。每个分区内的聚合变量用zeroValue初始化，然后聚合所有分区的结果。
    使用给定的关联函数和中性的“零值”，聚合每个分区的元素，。

  • 函数原型

def fold(zeroValue: T)(op: (T, T) => T): T
  • 使用举例
scala> val a = sc.parallelize(1 to 100, 3)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[33] at parallelize at <console>:24

scala> a.foreachPartition(c=>println(c.length))
scala> a.fold(0)(_+_)
res38: Int = 5050

aggregate

  • 函数功能
    aggregate函数允许用户将两种不同的reduce functions应用于RDD。 在每个分区中应用第一个reduce函数，以将每个分区内的数据减少为单个结果。第二个reduce函数用于将所有分区的不同缩减结果组合在一起，以得出最终结果。内部分区与跨分区减少具有两个单独的减少功能的能力增加了很大的灵活性。 例如，第一个reduce函数可以是max函数，第二个可以是sum函数。 用户还指定一个初始值。 但这里要注意：

    • 不要为分区计算或组合分区假定任何执行顺序。
    • 初始值适用于所有的reduce函数

  • 函数原型

 def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U
  • 使用举例
val z = sc.parallelize(List(1,2,3,4,5,6), 2)
z.aggregate(0)(math.max(_,_), _+_)

// 使用不同的集合函数
val z = sc.parallelize(List("12","23","345","4567"),2)
z.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)
res141: String = 42

aggregateByKey

  • 函数功能
    像聚合函数一样工作，除了聚合被应用于具有相同键的值。 也不像aggregate函数那样，初始值不适用于第二个reduce。
    参数zeroValue：执行第一个reduce函数的初始值。

  • 函数原型

def aggregateByKey[U: ClassTag](zeroValue: U, partitioner: Partitioner)(seqOp: (U, V)
  • 使用举例
scala> val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)
scala> pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect
res3: Array[(String, Int)] = Array((dog,12), (cat,17), (mouse,6))

scala> pairRDD.aggregateByKey(100)(math.max(_, _), _ + _).collect
res4: Array[(String, Int)] = Array((dog,100), (cat,200), (mouse,200))

count

  • 函数功能
    返回RDD中所有元素的个数。

  • 函数原型

def count(): Long
  • 使用举例
scala> val a = sc.parallelize(1 to 100, 3)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[7] at parallelize at <console>:24

scala> a.count()
res30: Long = 100

countByValue

  • 功能
    返回RDD中每个元素的个数，并按java的Map数据结构的方式返回。

  • 函数原型

def countByValue()(implicit ord: Ordering[T] = null): Map[T, Long]
  • 使用举例
scala> val a = sc.parallelize(1 to 10, 3)
a: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[12] at parallelize at <console>:24

scala> a.countByValue
res35: scala.collection.Map[Int,Long] = Map(5 -> 1, 10 -> 1, 1 -> 1, 6 -> 1, 9 -> 1, 2 -> 1, 7 -> 1, 3 -> 1, 8 -> 1, 4 -> 1)

scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "c", "b", "a", "a"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> r1.countByValue
res0: scala.collection.Map[String,Long] = Map(e -> 1, f -> 1, a -> 3, b -> 2, g -> 1, c -> 2, d -> 1)

zipWithIndex

take

  • 函数功能
    从RDD中返回n个元素。
    该函数先会先扫描一个分区，若分区的元素个数不够，则会扫描另一个分区，直到元素个数足够。
    注意：该函数会把所有的数据保存到driver端，所以若take的数据量太大，可能会导致OOM。

  • 函数原型

def take(num: Int): Array[T]
  • 使用举例
scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "c", "b", "a", "a"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> r1.take(3)
res4: Array[String] = Array(a, b, c)

first

  • 函数功能
    查找RDD的第一个数据项并返回它。

  • 函数原型

def first()
  • 使用举例
scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "c", "b", "a", "a"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> r1.first
res1: String = a

takeOrdered

  • 函数功能
    返回RDD的n个元素，并对这n个元素进行排序。

  • 函数原型

def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T]
  • 使用举例
scala> val r1 = sc.parallelize(Array("a", "b", "c", "d", "e", "f", "g", "c", "b", "a", "a"), 3)
r1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[1] at parallelize at <console>:24

scala> r1.takeOrdered(3)
res6: Array[String] = Array(a, a, a)

scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 2)
b: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[7] at parallelize at <console>:24

scala> b.takeOrdered(2)
res7: Array[String] = Array(ape, cat)

scala> b.takeOrdered(3)
res8: Array[String] = Array(ape, cat, dog)

top

  • 函数功能
    返回RDD的前n个元素。
    返回元素的顺序是按takeOrdered相反的顺序排列的。

  • 函数实现

  def top(num: Int)(implicit ord: Ordering[T]): Array[T] = withScope {
    takeOrdered(num)(ord.reverse)
  }
  • 使用举例
scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 2)
b: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[7] at parallelize at <console>:24

scala> b.top(3)
res12: Array[String] = Array(salmon, gnu, dog)

max

  • 功能
    返回RDD中最大的元素。

  • 函数原型

def max()(implicit ord: Ordering[T]): T
  • 使用举例
scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 2)
scala> b.max()
res13: String = salmon

isEmpty

  • 功能
    判断一个RDD是否为空。

  • 函数原型

def isEmpty(): Boolean
  • 使用举例
scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 2)
b: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[7] at parallelize at <console>:24

scala> b.isEmpty()
res16: Boolean = false

saveAsTextFile

  • 功能
    把RDD的内容保存到text文件中。

  • 函数原型

def saveAsTextFile(path: String): Unit
def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit
  • 使用举例

scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 3)
scala> b.saveAsTextFile("/user/zxh/testdata/rddresult1/")
$ hadoop fs -cat /user/zxh/testdata/rddresult1/*
dog
cat
ape
salmon
gnu

keyBy

  • 功能
    通过在每个数据项上应用一个函数来构造两部分元组（键 - 值对）。函数的结果成为键，原始数据项成为新创建的元组的值。

  • 函数原型

def keyBy[K](f: T => K): RDD[(K, T)]
  • 使用举例
val a = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"), 3)
val b = a.keyBy(_.length)
b.collect
res26: Array[(Int, String)] = Array((3,dog), (6,salmon), (6,salmon), (3,rat), (8,elephant))

keys

  • 函数功能
    从所有包含的元组中提取key，并将它们返回到新的RDD中。

  • 函数原型

def keys: RDD[K]
  • 使用举例
scala> val b = sc.parallelize(List("dog", "cat", "ape", "salmon", "gnu"), 3)
b: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> b.collect()
res2: Array[String] = Array(dog, cat, ape, salmon, gnu)

scala> val c = b.keyBy(_.length)
c: org.apache.spark.rdd.RDD[(Int, String)] = MapPartitionsRDD[4] at keyBy at <console>:26

scala> c.collect()
res4: Array[(Int, String)] = Array((3,dog), (3,cat), (3,ape), (6,salmon), (3,gnu))

scala> c.keys
res5: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[5] at keys at <console>:29

scala> c.keys.collect()
res6: Array[Int] = Array(3, 3, 3, 6, 3)
一 铭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark学习-RDD的实验
06-25
spark学习-RDD的实验
Spark实训5，spark RDD案例：统计每日新增用户
luog007的博客
06-20 1070
读取文件，得到RDD​（二）倒排，互换RDD中元组的元素顺序​（三）倒排后的RDD按键分组​（四）取分组后的日期集合最小值，计数为1​（五）按键计数，得到每日新增用户数（六）让输出结果按日期升序已知有以下用户访问历史数据，............
Spark RDD算子示例
最新发布
weixin_53898747的博客
04-09 523
转换算子和行动算子的示例
SparkRDD 案例：计算总成绩
CITTB的博客
06-21 413
积极
Spark 获取RDD案例详解
Dream_aju的博客
10-19 1280
1）获取内存中的RDD import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} //从内存中获取RDD object _01FromMemory { def main(args: Array[String]): Unit = { //配置文件 val conf: SparkConf = new SparkConf().setMaster("local")....
Spark4：RDD实例
定期分享我的发现和想法，感谢你的陪伴和支持
05-29 5715
Spark4：RDD实例一、词频统计实例二、键值对RDD1.创建键值对RDD2.键值对RDD转换操作①reduceByKey(func)②groupByKey()两者的区别③map④keys⑤values⑥sortByKey⑦mapValues(func)⑧join实例三、RDD数据读写 一、词频统计实例 读文件 拍扁 二、键值对RDD 1.创建键值对RDD ①加载数据 scala> val lines =sc.textFile("hdfs://localhost:9000/user/ha
Spark学习--RDD编码
05-09
RDD:弹性分布式数据集(ResilientDistributed Dataset),是Spark对数据的核心抽象。RDD其实是分布式的元素集合。当Spark对数据操作和转换时，会自动将RDD中的数据分发到集群，并将操作并行化执行。 Spark中的RDD是一...
spark-rdd-APi
12-14
内容根据spark rdd.scala和ParRDDFunctions.scala源码中rdd顺序整理，包含rdd功能解释。对熟悉spark rdd很有用
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
spark-rdd-sample1
04-29
spark-rdd-sample1
action函数详解（自定义action）
qwbtc的博客
04-14 6090
controller中自定义action： 1.添加路由 delete  '/dsdfas/:id/fdas/:home_id' => “controller#action” 2.controller中定义该action的函数 3.方法一:查其路由路径 类似edit_manage_path的,然后, 则匹配上路由delete动作的URL，会把URL的:id和:home_id分别由变量@a,
RDD中的转换和action（一）基本函数
legotime的博客
04-28 692
1基本操作：map、filter和flatmap 2、伪集合操作（distinct,union,intersection,substract,cartesian） 实验： //伪集合操作:返回的都是RDD val rdd2 = sc.parallelize(List(5,6,5,6,7,8,9,10,11,12,13)) //rdd2.distin
Spark RDD案例：分组排行榜（大数据实训02）
qq_56244269的博客
06-15 737
目录一、提出任务二、完成任务（一）新建Maven项目（二）添加相关依赖和构建插件（三）创建日志属性文件四）创建分组排行榜单例对象（五）本地运行程序，查看结果（六）交互式操作查看中间结果1、读取成绩文件得到RDD2、利用映射算子生成二元组构成的RDD3、按键分组得到新的二元组构成的RDD4、按值排序，取前三5、按指定格式输出结果 张三丰 90 李孟达 85 张三丰 87 王晓云 93 李孟达 65 张三丰 76 王晓云 78 李孟达 60 张三丰 94 王晓云 97 李孟达 88 张三丰 80 王晓云 88
spark的RDD中的action(执行)和transformation(转换)两种操作中常见函数介绍
helloxiaozhe的博客
11-08 2万+
spark的RDD中的action(执行)和transformation(转换)两种操作中常使用的函数 (1) 弹性分布式数据集（RDD） Spark是以RDD概念为中心运行的。RDD是一个容错的、可以被并行操作的元素集合。创建一个RDD有两个方法：在你的驱动程序中并行化一个已经存在的集合；从外部存储系统中引用一个数据集。RDD的一大特性是分布式存储，分布式存储在最大的好处是可以...
Spark-RDD实例
m0_46917254的博客
04-10 2900
综合实例 1.求TOP值 假设在某个目录下有若干个文本文件，每个文本文件里面包含了很多行数据，每行数据由4个数字构成，不同数字之间用逗号隔开。 如上：file1.txt和file2.txt里数据。 rdd = sc.textFile("file:///home/hadoop/program1/data/file*") #读取文件内容 rdd1 = rdd.flatMap(lambda x:x.split(",")) #用逗号分割数据 rdd2 = rdd1.map(lambda x:(i
通过例子学习spark rdd--Transformations函数
zg_hover的专栏
11-24 1606
Transformations函数 map floatMap flatMap 和 map filter distinct
spark RDD ，wordcount案例解析
路漫漫其修远兮，吾将上下而求索
11-24 1万+
spark RDD ，wordcount案例解析spark RDD 内存计算模型 数据来源:可以从HDFS文件，Hive表，Hbase，本地磁盘，MQ spark集群，RDD中的数据都是存放在worker，都分区的，你就可以简单的理解为worker就是分区，一个worker里面可以有多个partitionMaster 主节点将rdd划分为3个patition，存放数据源，在worker迭代
SparkRDD常用算子实践（附运行效果图）
Magician的博客
12-14 8683
SparkRDD算子分为两类：Transformation与Action. Transformation：即延迟加载数据，Transformation会记录元数据信息，当计算任务触发Action时，才会真正开始计算。 Action：即立即加载数据，开始计算。 创建RDD的方式有两种： 1、通过sc.textFile(“/root/words.txt”)从文件系统中创建 RDD。 2、#通...
Spark学习总结（一）
热门推荐
hellozhxy的博客
05-31 7万+
RDD及其特点1、RDD是Spark的核心数据模型，但是个抽象类，全称为Resillient Distributed Dataset，即弹性分布式数据集。2、RDD在抽象上来说是一种元素集合，包含了数据。它是被分区的，分为多个分区，每个分区分布在集群中的不同节点上，从而让RDD中的数据可以被并行操作。（分布式数据集）3、RDD通常通过Hadoop上的文件，即HDFS文件或者Hive表，来进行创建；...
spark所有action算子和transform算子
04-03
- filter(func)：传入一个函数，对RDD中的每个元素进行过滤操作，返回一个包含符合条件的元素的新RDD。 - flatMap(func)：传入一个函数，对RDD中每个元素进行映射操作，并返回多个元素，最终生成新的RDD。 - ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值