Spark系列二：SparkCore的RDD算子Transformation和Action详解

最新推荐文章于 2022-08-19 12:49:36 发布
最新推荐文章于 2022-08-19 12:49:36 发布
阅读量620 收藏 1
点赞数 1
分类专栏： spark Spark从入门（小白）到实战（精通啃源码）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37657725/article/details/94629080
版权

目录

概述

RDD 与 普通的集合有哪些区别

RDD的属性

创建RDD方式

RDD的算子  

RDD的Transformation的特点

常用的Transformation

aggregateByKey

​filterByRange

flatMapValues

foldByKey

combineByKey​

常用的Action

aggregate

collectAsMap

collect执行过程

 foreachPartition

countByKey 

 cache

checkpoint

总结

概述

  1. RDD是一个基本的抽象
  2. 操作RDD就像操作一个本地集合一样，不需要关心底层人物调度细节，降低了编程的复杂度。
  3. RDD可以认为是一个代理
  4.  RDD-（弹性分布式数据集）不存储真正要计算的数据，而是记录了RDD的转换关系（调用了什么方法，传入什么函数）
  5. 对RDD操作，他会在Driver端转换成Task，下发到Executor计算分散在多台集群上的数据

RDD 与 普通的集合有哪些区别

RDD里面记入的是描述信息（从哪里读数据、以后对数据如何进行计算）、RDD的方法分为两类Transformation（lazy）、Action（生成Task，并发送到Executor中执行）
Scala存储的是真正要计算的数据、执行方法后立即回返回结果

RDD的属性

  1. A list of partitions  （一系列分区，分区有编号，有顺序的），即数据集的基本组成单位。对于RDD来说，每个分片都会被一个计算任务处理，并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。
  2. A function for computing each split  （每一个切片都会有一个函数作业在上面用于对数据进行处理），一个计算每个分区的函数。Spark中RDD的计算是以分片为单位的，每个RDD都会实现compute函数以达到这个目的。compute函数会对迭代器进行复合，不需要保存每次计算的结果。
  3. A list of dependencies on other RDDs  （RDD和RDD之间存在依赖关系）。RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算。
  4. Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)，（可选，key value类型的RDD才有RDD[(K,V)]）如果是kv类型的RDD，会一个分区器，默认是hash-partitioned。即RDD的分片函数。当前Spark中实现了两种类型的分片函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。
  5. Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)，（可选，如果是从HDFS中读取数据，会得到数据的最优位置（向Namenode请求元数据））。一个列表，存储每个Partition的优先位置（preferred location）。对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。按照“移动数据不如移动计算”的理念，Spark在进行任务调度的时候，会尽可能地将计算任务分配到其所要处理数据块的存储位置。

创建RDD方式


        1.通过外部的存储系统创建RDD（读取HDFS文件）

            val rdd2 = sc.textFile("hdfs://lj01:9000/words.txt")


        2.将Driver的Scala集合通过并行化的方式编程RDD（试验、测验）

            val rdd1 = sc.parallelize(Array(1,2,3,4,5,6,7,8)）//由一个已经存在的Scala集合创建。
            val rdd1 = sc.makeRDD(List(1,2,3,4,5,6,7,8))，//makeRDD 底层调用的是parallelize

        3.调用一个已经存在了的RDD的Transformation，会生成一个新的RDD 

RDD的算子  

     RDD的算子分为两类，一类是Transformation（lazy），一类是Action（触发任务执行）

RDD的Transformation的特点

        1.lazy：不会直接计算结果，只是记住这些应用到一个文件上的转换动作，只有要求返回结果给Driver时，才会真正运行。
        2.生成新的RDD

常用的Transformation

转换

含义

map(func)

返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成

filter(func)

返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成

flatMap(func)

类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）

mapPartitions(func)

类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]

mapPartitionsWithIndex(func)

 //将对应分区中的数据取出来，并且带上分区编号, index是分区编号，it:里面的数据
val func = (index: Int, it: Iterator[Int]) => {
      it.map(e => s"part: $index, ele: $e")
    }

add.mapPartitionsWithIndex(func).collect

类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是     (Int, Interator[T]) => Iterator[U]

RDD的map方法，是Executor中执行时，是一条一条的将数据拿出来处理
mapPartitionsWithIndex 一次拿出一个分区（分区中并没有数据，而是记录要读取哪些数据，真正生成的Task会读取多条数据），并且可以将分区的编号取出来

功能：取分区中对应的数据时，还可以将分区的编号取出来，这样就可以知道数据是属于哪个分区的（哪个区分对应的Task的数据）

 

sample(withReplacement, fraction, seed)

根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子

union(otherDataset)

对源RDD和参数RDD求并集后返回一个新的RDD

intersection(otherDataset)

对源RDD和参数RDD求交集后返回一个新的RDD

distinct([numTasks]))

对源RDD进行去重后返回一个新的RDD

groupByKey([numTasks])     

在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD

reduceByKey(func, [numTasks])

在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置

aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])

 

sortByKey([ascending], [numTasks])

在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD

sortBy(func,[ascending], [numTasks])

与sortByKey类似，但是更灵活

join(otherDataset, [numTasks])

在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD

rdd1.cogroup(rdd2)

左边的每一个元素与右边的每一个元素求值

val rdd1 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
val rdd2 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))

rdd1.cartesian(rdd2) 

笛卡尔积：2*3=6

val rdd1 = sc.parallelize(List("tom", "jerry"))
val rdd2 = sc.parallelize(List("tom", "kitty", "shuke"))

pipe(command, [envVars])

 

coalesce(numPartitions)      

 

repartition(numPartitions)

 

repartitionAndSortWithinPartitions(partitioner)

 

rdd1.partitions.length查看该rdd的分区数量

aggregateByKey

val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)
def func2(index: Int, iter: Iterator[(String, Int)]) : Iterator[String] = {
      iter.map(x => "[partID:" +  index + ", val: " + x + "]")
}
pairRDD.mapPartitionsWithIndex(func2).collect
pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect //(dog,12),(cat,19),(mouse,6)
pairRDD.aggregateByKey(100)(math.max(_, _), _ + _).collect //(dog,112),(cat,219),(mouse,206)  它的初始值只在局部进行加，最后合并时不加初始值



filterByRange

val rdd1 = sc.parallelize(List(("e", 5), ("c", 3), ("d", 4), ("c", 2), ("a", 1)))
val rdd2 = rdd1.filterByRange("b", "d")
rdd2.colllect   //Array((c,3),(d,4),(c,2))  按照指定范围进行过滤,b到d,包含b和d

flatMapValues

val a = sc.parallelize(List(("a", "1 2"), ("b", "3 4")))
rdd3.flatMapValues(_.split(" "))  // Array((a,1),(a,2),(b,3),(b,4))

foldByKey

val rdd1 = sc.parallelize(List("dog", "wolf", "cat", "bear"), 2)

val rdd2 = rdd1.map(x => (x.length, x)) //Array((3,dog), (4,wolf), (3,cat), (4,bear))

rdd2.foldByKey("")(_+_).collect  //Array((3,dogcat), (4,wolfbear))
rdd2.aggregateByKey(" ")(_+_, _+_).collect  //Array((3,dogcat), (4,wolfbear))
rdd2.reduceByKey(_+_).collect  Array((3,dogcat), (4,wolfbear))
//以上三个方法底层都是调用"combineByKeywithClassTag"，都实现先局部聚合，在全局聚合

combineByKey

val rdd1 = sc.textFile("hdfs://lj01:9000/wc").flatMap(_.split(" ")).map((_, 1))
val rdd2 = rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
rdd2.collect

val rdd3 = rdd1.combineByKey(x => x + 10, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
rdd3.collect


val rdd4 = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"), 3)
val rdd5 = sc.parallelize(List(1,1,2,2,2,1,2,2,2), 3)
val rdd6 = rdd5.zip(rdd4)
val rdd7 = rdd6.combineByKey(List(_), (x: List[String], y: String) => x :+ y, (m: List[String], n: List[String]) => m ++ n)

常用的Action

动作

含义

reduce(func)

通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的

collect()

在驱动程序中，以数组的形式返回数据集的所有元素

aggregate先局部（分区）聚合，在整体聚合

count()

返回RDD的元素个数

first()

返回RDD的第一个元素（类似于take(1)）

take(n)

返回一个由数据集的前n个元素组成的数组

takeSample(withReplacement,num, [seed])

返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子

takeOrdered(n, [ordering])

 返回排序后的前n个元素。

saveAsTextFile(path)

将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

saveAsSequenceFile(path) 

将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。

saveAsObjectFile(path) 

 

countByKey()

针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。

foreach(func)

在数据集的每一个元素上，运行函数func进行更新。

aggregate

val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 2)
rdd1.mapPartitionsWithIndex(func1).collect
rdd1.aggregate(0)(math.max(_, _), _ + _)   // 18
rdd1.aggregate(5)(math.max(_, _), _ + _)   // 25


val rdd2 = sc.parallelize(List("a","b","c","d","e","f"),2)
def func2(index: Int, iter: Iterator[(String)]) : Iterator[String] = {
      iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
}
rdd2.aggregate("")(_ + _, _ + _)   // abcdef 或者 defabc 两个task，并行计算
rdd2.aggregate("=")(_ + _, _ + _)   // ==abc=def 或者==def=abc

val rdd3 = sc.parallelize(List("12","23","345","4567"),2)
rdd3.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)  // 42 或者24  2和4进行拼接，并行执行，哪个先，哪个在前

val rdd4 = sc.parallelize(List("12","23","345",""),2)
rdd4.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)  // 10或者01 ，空串长度是0，1是前面哪个分区，得到0.toString,得到0,0的长度是1

val rdd5 = sc.parallelize(List("12","23","","345"),2)
rdd5.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)   // 11

collectAsMap

val rdd = sc.parallelize(List(("a", 1), ("b", 2)))
rdd.collectAsMap //Map(b->2,a->1)  最终结果弄成Map收集回来到Driver,这样不好

rdd.mapvalues(_*100).collectAsMap   //Map(b->200,a->100) 阻塞方法，一定要等结果计算返回。

collect执行过程：

 foreachPartition

val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 3)
rdd1.foreachPartition(x => println(x.reduce(_ + _)))

foreachPartition 一个分区一个分区  适合去数据库写数据

foreach   一条一条  具体结果是在excute的log文件查看

countByKey 

val rdd1 = sc.parallelize(List(("a", 1), ("b", 2), ("b", 2), ("c", 2), ("c", 1)))
rdd1.countByKey // Map(a->1,b->2,c->2)  只看出现次数，与里面数值无关
rdd1.countByValue

 cache

RDD相关的持久化和缓存，是Spark最重要的特征之一。可以说，缓存是Spark构建迭代式算法和快速交互式查询的关键。

RDD通过persist方法或cache方法可以将前面的计算结果缓存，但是并不是这两个方法被调用时立即缓存，而是触发后面的action时，该RDD将会被缓存在计算节点的内存中，并供后面重用。

查看源码发现cache最终也是调用了persist方法

cache条件：
    1.要求的计算速度快
    2.集群的资源要足够大
    3.重要：cache的数据会多次的触发Action
    4.先进行过滤，然后将缩小范围的数据在cache到内存

默认的存储级别都是仅在内存存储一份，Spark的存储级别还有好多种，存储级别在object StorageLevel中定义的。

    //第一个参数，放到磁盘（速度快）
    //第二个参数，放到内存 （安全 ）
    //第三个参数，磁盘中的数据，不是以java对象的方式保存，序列化（默认的序列化）
    //第四个参数，内存中的数据，以java对象的方式保存，不序列化

    // 2,保存两份，在不同机器上 
    val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)

    OFF_HEAP:堆外内存

       例如：

              achyon，开源分布式内存存储系统

      改名 Alluxio - Open Source Memory Speed Virtual Distributed Storage

checkpoint

使用checkpoint场景：
    1.迭代计算，要求保证数据安全
    2.对速度要求不高（跟cache到内存进行对比）
    3.将中间结果保存到hdfs
 案列：

sc.setCheckpointDir("hdfs://lj01:9000/ck") //设置checkpoint目录（分布式文件系统的目录hdfs目录）
val rdd = sc.textFile("hdfs://lj01:9000/wc").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_)    //经过复杂进行，得到中间结果
rdd.checkpoint   //将中间结果checkpoint到指定的hdfs目录，是个标记，之前的父依赖关系就不用了
rdd.isCheckpointed
rdd.count   //后续的计算，就可以使用前面ck的数据了，做了两件事：写入HDFS，计算结果，所以可以在checkpoint之前先写入内存（避免相同的数据读两次），那么之后直接将内存写到HDFS，然后释放内存的数据
rdd.isCheckpointed
rdd.getCheckpointFile   

就做了cache又做了checkpoint，那么

在if判断在cache，内存找数据

在if判断是否checkpoint，HDFS找数据

在找父依赖看数据

总结

RDD是spark中的一个最基本的抽象，代表着一个不可变、可分区、可以并行计算的分布式数据集
RDD有5个特点
    1.一系列分区
    2.会有一个函数作用在每个切片上
    3.RDD和RDD之间存在依赖关系
    4（可选）如果是RDD中装的是KV类型的，那么Shuffle时会有一个分区器。默认是HashPartitioner
    5（可选）如果只从HDFS中读取数据，会感知数据则位置，将Executor启动在数据所在的机器上

Spark的设计就是基于这个抽象的数据集（RDD），你操作RDD这个抽象的数据集，就像操作一个本地集合一样，Spark包底层的细节都隐藏起来的（任务调度、Task执行，任务失败重试等待），开发者使用起来更加方便简洁

操作RDD，其实是对每个分区进行操作，分区会生成Task，Task会调度Executor上执行相关的计算逻辑，进而对数据进操作

如果您看到这了，请您动动小手点个赞或关注一下，鼓励一下我，谢谢您

静静七分醉
关注
专栏目录
Spark（4）RDD编程中的transformation算子和action算子使用与区别详解
weixin_43230682的博客
08-04 2270
前言 在上一篇文章中我们介绍了什么是RDD，以及RDD的属性、特征、依赖关系和缓存机制等等： Spark（3）架构原理、运行流程、RDD 那么，本文继续重点介绍一下RDD两类算子的使用。 一、编程模型 在Spark中，RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFil
[PySpark学习]RDD的转换（Transformation）与动作算子（Action）
最新发布
alie_123的博客
01-04 1514
RDD（英文全称Resilient Distributed Dataset），即弹性分布式数据集是spark中引入的一个数据结构，是Spark中最基本的数据抽象，代表一个不可变、可分区、里面的元素可并行计算的集合。Resilient弹性：RDD的数据可以存储在内存或者磁盘当中，RDD的数据可以分区。Distributed分布式：RDD的数据可以分布式存储，可以进行并行计算。Dataset数据集：一个用于存放数据的集合。
Spark Transformation和Action算子速查表.pdf
05-17
spark transformation & action 算子速查表，大数据实时和离线数据处理方向，希望对大家学习和工作有所帮助。
RDD的两种操作（Transformation和Action）
SunnyRivers
03-31 5817
RDD创建后就可以在RDD上进行数据处理。RDD支持两种操作：转换（transformation），即从现有的数据集创建一个新的数据集；动作（action），即在数据集上进行计算后，返回一个值给Driver程序。 RDD 的转化操作是返回一个新的 RDD 的操作，比如 map() 和 filter() ，而行动操作则是向驱动器程序返回结果或把结果写入外部系统的操作，会触发实际的计算，比如 coun...
RDD操作：Transformation与Action
简单随风的博客
08-21 533
Spark对RDD的操作可以整体分为两类: Transformation和Action 这里的Transformation可以翻译为转换，表示是针对RDD中数据的转换操作，主要会针对已有的RDD创建一个新的RDD: 常见的有map、flatMap、filter等等 Action可以翻译为执行，表示是触发任务执行的操作，主要对RDD进行最后的操作，比如遍历、 reduce、保存到文件等，并且还可以把结果返回给Driver程序 不管是Transformation里面的操作还是Action里面的操作，我们一般会把
Spark -- RDD两种算子：Transformation 和 Action
patrick_big_data的博客
02-24 1370
Transformation （1）map(func) 通过对RDD中每个元素执行一个function然后返回新的RDD /** * Return a new RDD by applying a function to all elements of this RDD. */ def map[U: ClassTag](f: T => U): RDD[U] 例如，将RDD中的...
Spark中RDD的transformation和action
li-zhang-yu的博客
01-17 515
一：transformation和action的区别 1，transformation是得到一个新的RDD，方式很多，比如从数据源生成一个新的RDD，从RDD生成一个新的RDD 2，action是得到一个值，或者一个结果（直接将RDDcache到内存中） 所有的transformation都是采用的懒策略，就是如果只是将transformation提交是不会执行计算的，计算只有在action...
Spark算子详解：Transformation与Action操作
"Spark算子的详细使用方法涵盖了Spark中的Transformation和Action两类算子，以及它们的细分类型，包括Value型、Key-Value型的Transformation算子和Action算子。核心概念是RDD（弹性分布式数据集），它是Spark计算的...
Spark算子基础：Scala版RDD操作详解
Spark算子分为转换算子（Transformation）和行动算子（Action）。转换算子不会立即执行任何计算，而是创建一个新的RDD（弹性分布式数据集）表示。而行动算子会触发实际的计算，并返回结果或写入数据到外部存储。 - ...
Spark-Transformation和Action算子.md
08-09
### Spark Transformation和Action算子详解 #### 一、Transformation **Transformation** 在 Spark 中是指对 RDD（弹性分布式数据集）进行的各种转换操作。这些操作并不会立即执行，而是延迟执行，直到遇到 Action...
SparkCore：RDD的Transformations、Actions算子
11号车厢
08-01 656
文章目录 官网：RDD Operations http://spark.apache.org/docs/2.4.2/rdd-programming-guide.html#rdd-operations
【分布式计算框架】Spark RDD五大属性剖析 | Action 和 Transformations 算子​
康师傅没有眼泪
03-28 1482
RDD 是只读的, 不允许任何形式的修改. 虽说不能因为 RDD 和 HDFS 是只读的, 就认为分布式存储系统必须设计为只读的. 但是设计为只读的, 会显著降低问题的复杂度, 因为 RDD 需要可以容错, 可以惰性求值, 可以移动计算, 所以很难支持修改.
RDD -- Transformation算子分析
qq_40337206的博客
05-15 643
RDD RDD(Resilient Distributed Datasets) ,弹性分布式数据集， 是分布式内存的一个抽象概念，RDD提供了一种高度受限的共享内存模型，即RDD是只读的记录分区的集合，只能通过在其他RDD执行确定的转换操作（如map、join和group by）而创建，然而这些限制使得实现容错的开销很低。对开发者而言，RDD可以看作是Spark的一个对象，它本身运行于内存中，如...
spark三 算子简介
04-02 537
RDD中的所有转换都是延迟加载的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让Spark更加有效率地运行。 也就是说Transformation算子，spark程序没有计算，遇到action算子开始计算 Transformation 算子 介绍 ...
Spark Transformation和Action算子速查表
Allenzyg的博客
09-23 223
Transformation算子 Transformation算子 作用 map(func) 返回一个新的分布式数据集，其中每个元素都是由源RDD中每一个元素经过func函数转换得到的 filter(func) 返回一个新的数据集，其中包含的元素来自源RDD元素经过func函数过滤后的结果（func函数返回true的结果） flatMap(func)
Spark RDD 之间的依赖关系
01-30 1254
RDD就是一个不可变的带分区的记录集合，Spark提供了RDD上的两类操作，转换（transformation）和动作（action）。 转换是用来定义一个新的RDD，包括map, flatMap, filter, union, sample, join, groupByKey, cogroup, ReduceByKey, cros, sortByKey, mapValues等。 动作是返回一个...
常见算子使用_【每日一题】Spark的算子可以分为哪两类，区别是什么？
bobo的博客
01-15 878
大家好，我是勾叔。今天的面试题是：Spark的算子可以分哪两类，这两类算子的区别是什么？并分别列举6个这两类算子，列举6个会产生Shuffle的算子。问题分析考察基本功，从多个维度考察对算子的理解。核心问题回答Spark的算子可以分为两类：Transformation、Action。Transformation：从现有的数据集创建一个新的数据集，返回一个新的 RDD 操作。Transfo...
Spark Transformation与Action
libaowenBlog的博客
08-19 494
常见的action算子、常见的transformation算子、 map 将RDD中的每个元素进行处理，一进一出 filter 对RDD中每个元素进行判断，返回true则保留 flatMap 与map类似，但是每个元素都可以返回一个或多个新元素 groupByKey reduce：聚合计算 collect：获取元素集合 take(n)：获取前n个元素 count：获取元素总数 saveAsTextFile： countByKey：统计相同的key出现多少次 foreach：迭代遍历元素
【spark】Spark transformation和action的算子
开发随笔-猫咪酱
08-01 3701
transformation算子 map(func) 返回一个新的分布式数据集，由每个原元素经过func函数处理后的新元素组成 filter(func) 返回一个新的数据集，由经过func函数处理后返回值为true的原元素组成 flatMap(func) 类似于map，但是每一个输入元素，会被映射为0个或多个输出元素，(因此，func函数的返回值是一个seq，而不是单一元素)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值