Spark RDD Transformation 详解

最新推荐文章于 2022-07-08 14:29:03 发布
最新推荐文章于 2022-07-08 14:29:03 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： Apache Spark 文章标签： Spark RDD Transforma Spark RDD

这几天学习了Spark RDD transformation 和 action ，做个笔记记录下心得，顺便分享给大家。

下面的表格列出了目前所支持的转换和动作（详情请参见 RDD API doc）：

转换（transformation）

 转换含义
map(func)返回一个新分布式数据集，由每一个输入元素经过func函数转换后组成
filter(func)返回一个新数据集，由经过func函数计算后返回值为true的输入元素组成
flatMap(func)类似于map，但是每一个输入元素可以被映射为0或多个输出元素（因此func应该返回一个序列，而不是单一元素）
mapPartitions(func)类似于map，但独立地在RDD的每一个分块上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithSplit(func)类似于mapPartitions, 但func带有一个整数参数表示分块的索引值。因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Iterator[T]) => Iterator[U]
sample(withReplacement,fraction, seed)根据fraction指定的比例，对数据进行采样，可以选择是否用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset)返回一个新的数据集，新数据集是由源数据集和参数数据集联合而成
distinct([numTasks]))返回一个包含源数据集中所有不重复元素的新数据集
groupByKey([numTasks])在一个（K,V）对的数据集上调用，返回一个（K，Seq[V])对的数据集
注意：默认情况下，只有8个并行任务来做操作，但是你可以传入一个可选的numTasks参数来改变它
reduceByKey(func, [numTasks])在一个（K，V)对的数据集上调用时，返回一个（K，V）对的数据集，使用指定的reduce函数，将相同key的值聚合到一起。类似groupByKey，reduce任务个数是可以通过第二个可选参数来配置的
sortByKey([ascending], [numTasks])在一个（K，V)对的数据集上调用，K必须实现Ordered接口，返回一个按照Key进行排序的（K，V）对数据集。升序或降序由ascending布尔参数决定
join(otherDataset, [numTasks])在类型为（K,V)和（K,W)类型的数据集上调用时，返回一个相同key对应的所有元素对在一起的(K, (V, W))数据集
cogroup(otherDataset, [numTasks])在类型为（K,V)和（K,W)的数据集上调用，返回一个 (K, Seq[V], Seq[W])元组的数据集。这个操作也可以称之为groupwith
cartesian(otherDataset)笛卡尔积，在类型为 T 和 U 类型的数据集上调用时，返回一个 (T, U)对数据集(两两的元素对)

完整的转换列表可以在RDD API doc中获得。

动作（actions）

 动作含义
reduce(func)通过函数func（接受两个参数，返回一个参数）聚集数据集中的所有元素。这个功能必须可交换且可关联的，从而可以正确的被并行执行。
collect()在驱动程序中，以数组的形式，返回数据集的所有元素。这通常会在使用filter或者其它操作并返回一个足够小的数据子集后再使用会比较有用。
count()返回数据集的元素的个数。
first()返回数据集的第一个元素（类似于take（1））
take(n)返回一个由数据集的前n个元素组成的数组。注意，这个操作目前并非并行执行，而是由驱动程序计算所有的元素
takeSample(withReplacement,num, seed)返回一个数组，在数据集中随机采样num个元素组成，可以选择是否用随机数替换不足的部分，Seed用于指定的随机数生成器种子
saveAsTextFile(path)将数据集的元素，以textfile的形式，保存到本地文件系统，HDFS或者任何其它hadoop支持的文件系统。对于每个元素，Spark将会调用toString方法，将它转换为文件中的文本行
saveAsSequenceFile(path)将数据集的元素，以Hadoop sequencefile的格式，保存到指定的目录下，本地系统，HDFS或者任何其它hadoop支持的文件系统。这个只限于由key-value对组成，并实现了Hadoop的Writable接口，或者隐式的可以转换为Writable的RDD。（Spark包括了基本类型的转换，例如Int，Double，String，等等）
countByKey()对(K,V)类型的RDD有效，返回一个(K，Int)对的Map，表示每一个key对应的元素个数
foreach(func)在数据集的每一个元素上，运行函数func进行更新。这通常用于边缘效果，例如更新一个累加器，或者和外部存储系统进行交互，例如HBase

完整的转换列表可以在RDD API doc中获得。


1. 启动spark-shell 

[java]  view plain copy
  1. SPARK_MASTER=local[4] ./spark-shell.sh  
[java]  view plain copy
  1. Welcome to  
  2.       ____              __    
  3.      / __/__  ___ _____/ /__  
  4.     _\ \/ _ \/ _ `/ __/  '_/  
  5.    /___/ .__/\_,_/_/ /_/\_\   version 0.8.1  
  6.       /_/                    
  7.   
  8.   
  9. Using Scala version 2.9.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_20)  
  10. Initializing interpreter...  
  11. 14/04/04 10:49:44 INFO server.Server: jetty-7.x.y-SNAPSHOT  
  12. 14/04/04 10:49:44 INFO server.AbstractConnector: Started SocketConnector@0.0.0.0:5757  
  13. Creating SparkContext...  
  14. 14/04/04 10:49:50 INFO slf4j.Slf4jEventHandler: Slf4jEventHandler started  
  15. 14/04/04 10:49:50 INFO spark.SparkEnv: Registering BlockManagerMaster  
  16. 14/04/04 10:49:50 INFO storage.DiskBlockManager: Created local directory at /tmp/spark-local-20140404104950-5dd2  

2.我们就拿根目录下的CHANGES.txt和README.txt文件做示例吧。

[java]  view plain copy
  1. scala> sc  
  2. res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@5849b49d  
  3.   
  4. scala> val changes = sc.textFile("CHANGES.txt")  
  5. 14/04/04 10:51:39 INFO storage.MemoryStore: ensureFreeSpace(44905) called with curMem=0, maxMem=339585269  
  6. 14/04/04 10:51:39 INFO storage.MemoryStore: Block broadcast_0 stored as values to memory (estimated size 43.9 KB, free 323.8 MB)  
  7. changes: org.apache.spark.rdd.RDD[String] = MappedRDD[1] at textFile at <console>:12  
  8.   
  9. scala> changes foreach println  
  10. 14/04/04 10:52:03 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable  
  11. 14/04/04 10:52:03 WARN snappy.LoadSnappy: Snappy native library not loaded  
  12. 14/04/04 10:52:03 INFO mapred.FileInputFormat: Total input paths to process : 1  
  13. 14/04/04 10:52:03 INFO spark.SparkContext: Starting job: foreach at <console>:15  
  14. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Got job 0 (foreach at <console>:15) with 1 output partitions (allowLocal=false)  
  15. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Final stage: Stage 0 (foreach at <console>:15)  
  16. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Parents of final stage: List()  
  17. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Missing parents: List()  
  18. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Submitting Stage 0 (MappedRDD[1] at textFile at <console>:12), which has no missing parents  
  19. 14/04/04 10:52:03 INFO scheduler.DAGScheduler: Submitting 1 missing tasks from Stage 0 (MappedRDD[1] at textFile at <console>:12)  
  20. 14/04/04 10:52:03 INFO local.LocalTaskSetManager: Size of task 0 is 1664 bytes  
  21. 14/04/04 10:52:03 INFO executor.Executor: Running task ID 0  
  22. 14/04/04 10:52:03 INFO storage.BlockManager: Found block broadcast_0 locally  
  23. 14/04/04 10:52:03 INFO rdd.HadoopRDD: Input split: file:/app/home/hadoop/shengli/spark-0.8.1-incubating-bin-hadoop1/CHANGES.txt:0+65951  
  24. Spark Change Log  
  25.   
  26. Release 0.8.1-incubating  
  27.   
  28.   d03589d Mon Dec 9 23:10:00 2013 -0800  
  29.   Merge pull request #248 from colorant/branch-0.8  
  30.   [Fix POM file for mvn assembly on hadoop 2.2 Yarn]  
  31.   
  32.   3e1f78c Sun Dec 8 21:34:12 2013 -0800  
  33.   Merge pull request #195 from dhardy92/fix_DebScriptPackage  
  34.   [[Deb] fix package of Spark classes adding org.apache prefix in scripts embeded in .deb]  
  35.   
  36.   c14f373 Sat Dec 7 22:35:31 2013 -0800  
  37.   Merge pull request #241 from pwendell/master  
  38.   [Update broken links and add HDP 2.0 version string]  
  39.   
  40.   9c9e71e Sat Dec 7 12:47:26 2013 -0800  
  41.   Merge pull request #241 from pwendell/branch-0.8  
  42.   [Fix race condition in JobLoggerSuite [0.8 branch]]  
  43.   
  44.   92597c0 Sat Dec 7 11:58:00 2013 -0800  
  45.   Merge pull request #240 from pwendell/master  
  46.   [SPARK-917 Improve API links in nav bar]  
  47.   
  48.   cfca70e Sat Dec 7 01:15:20 2013 -0800  
  49.   Merge pull request #236 from pwendell/shuffle-docs  
  50.   [Adding disclaimer for shuffle file consolidation]  

现在要找出所有包含Merge的文字

filter

现在要找出所有包含Merge的文字

[java]  view plain copy
  1. scala> val mergeLines = changes.filter(_.contains("Merge"))  
  2. mergeLines: org.apache.spark.rdd.RDD[String] = FilteredRDD[2] at filter at <console>:14  
  3.   
  4.   
  5. scala> mergeLines foreach println  
  6. 14/04/04 10:54:52 WARN util.NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable  
  7. 14/04/04 10:54:52 WARN snappy.LoadSnappy: Snappy native library not loaded  
  8. 14/04/04 10:54:52 INFO mapred.FileInputFormat: Total input paths to process : 1  
  9. 14/04/04 10:54:52 INFO spark.SparkContext: Starting job: foreach at <console>:17  
  10. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Got job 0 (foreach at <console>:17) with 1 output partitions (allowLocal=false)  
  11. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Final stage: Stage 0 (foreach at <console>:17)  
  12. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Parents of final stage: List()  
  13. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Missing parents: List()  
  14. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Submitting Stage 0 (FilteredRDD[2] at filter at <console>:14), which has no missing parents  
  15. 14/04/04 10:54:52 INFO scheduler.DAGScheduler: Submitting 1 missing tasks from Stage 0 (FilteredRDD[2] at filter at <console>:14)  
  16. 14/04/04 10:54:52 INFO local.LocalTaskSetManager: Size of task 0 is 1733 bytes  
  17. 14/04/04 10:54:52 INFO executor.Executor: Running task ID 0  
  18. 14/04/04 10:54:52 INFO storage.BlockManager: Found block broadcast_0 locally  
  19. 14/04/04 10:54:52 INFO rdd.HadoopRDD: Input split: file:/app/home/hadoop/shengli/spark-0.8.1-incubating-bin-hadoop1/CHANGES.txt:0+65951  
  20.   Merge pull request #248 from colorant/branch-0.8  
  21.   Merge pull request #195 from dhardy92/fix_DebScriptPackage  
  22.   Merge pull request #241 from pwendell/master  
  23.   Merge pull request #241 from pwendell/branch-0.8  
  24.   Merge pull request #240 from pwendell/master  
  25.   Merge pull request #236 from pwendell/shuffle-docs  
  26.   Merge pull request #237 from pwendell/formatting-fix  
  27.   Merge pull request #235 from pwendell/master  
  28.   Merge pull request #234 from alig/master  
  29.   Merge pull request #199 from harveyfeng/yarn-2.2  
  30.   Merge pull request #101 from colorant/yarn-client-scheduler  
  31.   Merge pull request #191 from hsaputra/removesemicolonscala  
  32.   Merge pull request #178 from hsaputra/simplecleanupcode  
  33.   Merge pull request #189 from tgravescs/sparkYarnErrorHandling  
  34.   Merge pull request #232 from markhamstra/FiniteWait  
  35.   Merge pull request #231 from pwendell/branch-0.8  
  36.   Merge pull request #228 from pwendell/master  
  37.   Merge pull request #227 from pwendell/master  
  38.   Merge pull request #223 from rxin/transient  
  39.   Merge pull request #95 from aarondav/perftest  
  40.   Merge pull request #218 from JoshRosen/spark-970-pyspark-unicode-error  
  41.   Merge pull request #181 from BlackNiuza/fix_tasks_number  
  42.   Merge pull request #219 from sundeepn/schedulerexception  
  43.   Merge pull request #201 from rxin/mappartitions  
  44.   Merge pull request #197 from aarondav/patrick-fix  
  45.   Merge pull request #200 from mateiz/hash-fix  
  46.   Merge pull request #193 from aoiwelle/patch-1  
  47.   Merge pull request #196 from pwendell/master  
  48.   Merge pull request #174 from ahirreddy/master  
  49.   Merge pull request #166 from ahirreddy/simr-spark-ui  
  50.   Merge pull request #137 from tgravescs/sparkYarnJarsHdfsRebase  
  51.   Merge pull request #165 from NathanHowell/kerberos-master  
  52.   Merge pull request #153 from ankurdave/stop-spot-cluster  
  53.   Merge pull request #160 from xiajunluan/JIRA-923  
  54.   Merge pull request #175 from kayousterhout/no_retry_not_serializable  
  55.   Merge pull request #173 from kayousterhout/scheduler_hang  

map

[java]  view plain copy
  1. scala> mergeLines.map(line=>line.split(" "))  
  2. res2: org.apache.spark.rdd.RDD[Array[java.lang.String]] = MappedRDD[3] at map at <console>:17  
  3.   
  4. scala> mergeLines.map(line=>line.split(" ")) take 10  
  5. 14/04/04 11:05:24 INFO spark.SparkContext: Starting job: take at <console>:17  
  6. 14/04/04 11:05:24 INFO scheduler.DAGScheduler: Got job 1 (take at <console>:17) with 1 output partitions (allowLocal=true)  
  7. 14/04/04 11:05:24 INFO scheduler.DAGScheduler: Final stage: Stage 1 (take at <console>:17)  
  8. 14/04/04 11:05:24 INFO scheduler.DAGScheduler: Parents of final stage: List()  
  9. 14/04/04 11:05:24 INFO scheduler.DAGScheduler: Missing parents: List()  
  10. 14/04/04 11:05:24 INFO scheduler.DAGScheduler: Computing the requested partition locally  
  11. 14/04/04 11:05:24 INFO rdd.HadoopRDD: Input split: file:/app/home/hadoop/shengli/spark-0.8.1-incubating-bin-hadoop1/CHANGES.txt:0+65951  
  12. 14/04/04 11:05:24 INFO spark.SparkContext: Job finished: take at <console>:17, took 0.010779038 s  
  13. res3: Array[Array[java.lang.String]] = Array(Array("", "", Merge, pull, request, #248, from, colorant/branch-0.8), Array("", "", Merge, pull, request, #195, from, dhardy92/fix_DebScriptPackage), Array("", "", Merge, pull, request, #241, from, pwendell/master), Array("", "", Merge, pull, request, #241, from, pwendell/branch-0.8), Array("", "", Merge, pull, request, #240, from, pwendell/master), Array("", "", Merge, pull, request, #236, from, pwendell/shuffle-docs), Array("", "", Merge, pull, request, #237, from, pwendell/formatting-fix), Array("", "", Merge, pull, request, #235, from, pwendell/master), Array("", "", Merge, pull, request, #234, from, alig/master), Array("", "", Merge, pull, request, #199, from, harveyfeng/yarn-2.2))  

可以看出，map最后输出的数据集是Array(array1,array2....)这样的嵌套数组
[java]  view plain copy
  1. scala> val splitedLine = mergeLines.map(line=>line.split(" "))  
  2. splitedLine: org.apache.spark.rdd.RDD[Array[java.lang.String]] = MappedRDD[5] at map at <console>:16  

flatMap

flatMap其实就是将数据集给扁平化了，变成了1个Seq或者Array
[java]  view plain copy
  1. scala> changes.flatMap(line=>line.split(" ")) take 10  
  2. 14/04/04 11:18:26 INFO spark.SparkContext: Starting job: take at <console>:15  
  3. 14/04/04 11:18:26 INFO scheduler.DAGScheduler: Got job 17 (take at <console>:15) with 1 output partitions (allowLocal=true)  
  4. 14/04/04 11:18:26 INFO scheduler.DAGScheduler: Final stage: Stage 17 (take at <console>:15)  
  5. 14/04/04 11:18:26 INFO scheduler.DAGScheduler: Parents of final stage: List()  
  6. 14/04/04 11:18:26 INFO scheduler.DAGScheduler: Missing parents: List()  
  7. 14/04/04 11:18:26 INFO scheduler.DAGScheduler: Computing the requested partition locally  
  8. 14/04/04 11:18:26 INFO rdd.HadoopRDD: Input split: file:/app/home/hadoop/shengli/spark-0.8.1-incubating-bin-hadoop1/CHANGES.txt:0+65951  
  9. 14/04/04 11:18:26 INFO spark.SparkContext: Job finished: take at <console>:15, took 0.003913527 s  
  10. res26: Array[java.lang.String] = Array(Spark, Change, Log, "", Release, 0.8.1-incubating, "", "", "", d03589d)  

union

[java]  view plain copy
  1. changes.union(changes) foreach println  

groupByKey, reduceByKey

[java]  view plain copy
  1. scala> val wordcount = changes.flatMap(line=>line.split(" ")).map(word=>(word,1))  
  2. wordcount: org.apache.spark.rdd.RDD[(java.lang.String, Int)] = MappedRDD[22] at map at <console>:14  
  3. map后打印出来如下：  
  4. (#534,1)  
  5. (from,1)  
  6. (stephenh/removetrycatch,1)  
  7. (,1)  
  8. (,1)  
  9. ([Remove,1)  
  10. (try/catch,1)  
  11. (block,1)  
  12. (that,1)  
  13. (can't,1)  
  14. (be,1)  
  15. (hit.],1)  
  16. (,1)  
  17. (,1)  
  18. (,1)  
  19.   
  20. 用groupByKey来形成shuffle后的结果  
  21.   
  22. wordcount.groupByKey() foreach println  
  23.   
  24. 这里的key是[Automatically，LogQuery.   
  25. value是一个数组list[v]  
  26.   
  27. ([Automatically,ArrayBuffer(1))  
  28. (LogQuery,ArrayBuffer(1))  
  29. (2d3eae2,ArrayBuffer(1))  
  30. (#130,ArrayBuffer(1))  
  31. (8e9bd93,ArrayBuffer(1))  
  32. (8,ArrayBuffer(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1))  
  33.   
  34. 用reduceByKey来计算wordcount,个人感觉reduceByKey = groupByKey + aggregate function on list[v]  
  35. wordcount.reduceByKey(_+_) foreach println  
  36. 结果如下：  
  37. (instructions,2)  
  38. (Adds,1)  
  39. (ssh,1)  
  40. (#691,1)  
  41. (#863,1)  
  42. (README],2)  
  43. (#676,1)  
  44. (javadoc,1)  
  45. (#571,1)  
  46. (0f1b7a0,1)  
  47. (shimingfei/joblogger,1)  
  48. (links,2)  
  49. (memory-efficient,1)  
  50. (pwendell/akka-standalone,1)  
  51. (hsaputra/update-pom-asf,1)  
  52. (method],1)  
  53. (mapPartitionsWithIndex],1)  
  54. (key-value,1)  
  55. (22:19:00,1)  
  56. (sbt,4)  
  57. (e5b9ed2,1)  
  58. (loss,1)  
  59. (stephenh/volatile,1)  
  60. (code,6)  

distinct

[java]  view plain copy
  1. distinct类似java中的set，去重。  
  2. scala> wordcount.count()  
  3. res43: Long = 12222  
  4.   
  5. wordcount.distinct.count()  
  6. res44: Long = 3354  

sortByKey

依据key排序，true为升序，false降序
[java]  view plain copy
  1. wordcount.sortByKey(true) take 10  
  2. res10: Array[(java.lang.String, Int)] = Array(("",1), ("",1), ("",1), ("",1), ("",1), ("",1), ("",1), ("",1), ("",1), ("",1))  
  3.   
  4. wordcount.sortByKey(false) take 10  
  5. res11: Array[(java.lang.String, Int)] = Array(({0,1},1), (zookeeper,1), (zip,1), (zip,1), (zip,1), (zero-sized,1), (zero,1), (yarn],1), (yarn.version,1), (yarn.version,1))  

join

这里为了避免""值在join的影响，过滤掉""元素
[java]  view plain copy
  1. val wordcount = changes.flatMap(line=>line.split(" ")).filter(_!="").map(word=>(word,1)).reduceByKey(_+_)  
  2.   
  3. scala> val readme = sc.textFile("README.md")  
  4. scala> val readMeWordCount = readme.flatMap(_.split(" ")).filter(_!="").map(word=>(word,1)).reduceByKey(_+_)  
  5.   
  6. scala> wordcount.join(readMeWordCount)  
  7. res3: org.apache.spark.rdd.RDD[(java.lang.String, (Int, Int))] = FlatMappedValuesRDD[36] at join at <console>:21  
  8.   
  9. 结果会将相同的key的value整合到一个list里，即key,list[v from wordcount..., v from readMeWordCount...]  
  10. wordcount.join(readMeWordCount) take 20  
  11. res6: Array[(java.lang.String, (Int, Int))] = Array((at,(1,2)), (do,(1,1)), (by,(9,5)), (ASF,(2,1)), (adding,(3,1)), (all,(2,1)), (versions,(6,4)), (sbt/sbt,(1,6)), (under,(2,2)), (set,(7,1)))  

cogroup

这个操作是将两个数据集join后，相同的key，的value会变成[seq1 from left],[seq from right]
[java]  view plain copy
  1. wordcount.cogroup(readMeWordCount,2).filter(_._1==("do")) take 10  
  2. res18: Array[(java.lang.String, (Seq[Int], Seq[Int]))] = Array((do,(ArrayBuffer(1),ArrayBuffer(1))))  
  3. 这两个ArrayBuffer第一个是来自左表，第二个来自右表。  

cartesian

笛卡尔积，，，你懂的。。。m*n,,数据量大了话，不要随便试玩。。
[java]  view plain copy
  1. wordcount.count  
  2. 3353  
  3. readMeWordCount.count  
  4. res25: Long = 324  
  5.   
  6. wordcount.cartesian(readMeWordCount,2)  
  7. res23: Long = 1086372  
  8.   
  9. 3353 * 324 = 1086372  

原创，转载请注明出处 http://blog.csdn.net/oopsoom/article/details/22918991,谢谢。
scalad
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark RDD操作详解
09-25
RDD即弹性分布式数据集，有容错机制并可以被并行操作的元素集合，具有只读、分区、容错、高效、无需物化、可以缓存、RDD依赖等特征。RDD只是数据集的抽象，分区内部并不会存储具体的数据。
RDD—Transformation算子
JStana的博客
11-25 816
RDD-Transformation 算子
RDD转换(Transformation)操作
TSY_1222的博客
07-12 1355
1、filter(func) （filter—翻译—>过滤） 筛选出满足函数func的元素，并返回一个新的数据集。 在第3行中，filter()的输入参数line => line.contains("Spark")是一个匿名函数，或者被称为“λ表达式”。 filter(line => line.contains("Spark"))的含义：依次取出lines这个RD...
【回顾】RDD的转换算子 Transform
懂得一千零一种,赋予你失败的方法！
01-02 883
文章目录一、概念二、RDD的转换算子♑ Value类型1、map2、mapPartitions3、mapPartitionWithIndex4、flatMap5、glom6、groupBy7、filter8、sample9、distinct10、coalesce11、repartition12、sortBy♑ 双Value类型♑ Key-Value类型 一、概念 RDD方法 称之为 RDD算子 认知心理学人为解决问题其实将问题的状态进行改变 问题（初始）-> 操作（算子）-> 问题（审..
RDD的转换（Transformation）操作
Nice的博客
09-09 4580
1.map(func) 返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成 Map算子是对于输入的数据进行定义函数的操作，可以返回其他类型的参数，Map操作应用于传入的每一个数据。 scala> var source = sc.parallelize(1 to 10) source: org.apache.spark.rdd.RDD[Int] = ParallelCol...
Spark学习笔记(3) - 关于Spark常用的transform算子的一些总结⭐️⭐️⭐️
兀坐晴窗独饮茶
07-28 384
RDD 常用 transform 算子
Spark RDD详解
01-07
Spark与Apache Hadoop有何关系？ Spark是与Hadoop数据兼容的快速通用处理引擎。它可以通过YARN或Spark的Standalone在Hadoop集群中运行，并且可以处理HDFS、Hbase、Cassandra、Hive和任何Hadoop InputFormat中的数据...
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
spark rdd 操作详解
04-22
spark rdd相关操作详解;包括全部的操作说明和举例；
sparkRDD函数大全
02-28
spark rdd函数大全。spark rdd操作为core操作，虽然后续版本主要以dataset来操作，但是rdd操作也是不可忽略的一部分。
RDD的两种操作（Transformation和Action）
SunnyRivers
03-31 5559
RDD创建后就可以在RDD上进行数据处理。RDD支持两种操作：转换（transformation），即从现有的数据集创建一个新的数据集；动作（action），即在数据集上进行计算后，返回一个值给Driver程序。 RDD 的转化操作是返回一个新的 RDD 的操作，比如 map() 和 filter() ，而行动操作则是向驱动器程序返回结果或把结果写入外部系统的操作，会触发实际的计算，比如 coun...
Spark学习之路（三）【RDD编程 API——转换算子Transformation】
高興
06-25 465
RDD编程API Spark支持两个类型（算子）操作：Transformation和Action Transformation 主要做的是就是将一个已有的RDD生成另外一个RDD。Transformation具有lazy特性(延迟加载)。Transformation算子的代码不会真正被执行。只有当我们的程序里面遇到一个action算子的时候，代码才会真正的被执行。这种设计让Spark更加有效率地运...
Spark之 RDD Transformations 案例
qq_33465047的博客
05-29 308
RDD Transformations are Spark operations when executed on RDD, it results in a single or multiple new RDD’s. Since RDD are immutable in nature, transformations always create new RDD without updating an existing one hence, this creates an RDD lineage. RDD.
Spark的RDD（transformations）
weixin_45102492的博客
03-07 193
RDD概述 RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据（计算）抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。 RDD的属性 一组分区（Partition），即数据集的基本组成单位; 一个计算每个分区的函数; RDD之间的依赖关系; 一个Partitioner，即RDD的分片函数; 一个列表...
RDD操作：Transformation与Action
简单随风的博客
08-21 458
Spark对RDD的操作可以整体分为两类: Transformation和Action 这里的Transformation可以翻译为转换，表示是针对RDD中数据的转换操作，主要会针对已有的RDD创建一个新的RDD: 常见的有map、flatMap、filter等等 Action可以翻译为执行，表示是触发任务执行的操作，主要对RDD进行最后的操作，比如遍历、 reduce、保存到文件等，并且还可以把结果返回给Driver程序 不管是Transformation里面的操作还是Action里面的操作，我们一般会把
【RDD】Transformations
yuxeaotao的博客
07-08 252
RDD Transformations是Spark在RDD上执行的操作，它会产生一个或多个新的RDD。由于RDD在本质上是不可变的，Transformations总是创建新的RDD，而不更新现有的RDD，因此，这就创建了一个RDD lineage。 RDD谱系（RDD Lineage）也被称为RDD操作图或RDD依赖图。RDD Transformations是惰性操作，这意味着除非在Spark RDD上调用一个action，否则不会执行任何Transformation。由于RDD是不可变的，任何对它的转换都
Spark Core (一) 什么是RDD的Transformation和Action以及Dependency（转载）
weixin_30340745的博客
06-21 87
1. Spark的RDD RDD(Resilient Distributed Datasets),弹性分布式数据集，是对分布式数据集的一种抽象。 RDD所具备5个主要特性： 一组分区列表 计算每一个数据分片的函数 RDD上的一组依赖 对于Key Value 对的RDD，会有一个Partitioner, 这是数据的分区器，控制数据分区策略和数量 一组Preferred Loca...
本地windows跑Scala程序调用Spark
weixin_33694172的博客
11-21 391
应用场景 spark是用scala写的一种极其强悍的计算工具，spark内存计算，提供了图计算，流式计算，机器学习，即时查询等十分方便的工具，所以利用scala来进行spark编程是十分必要的，下面简单书写一个spark连接mysql读取信息的例子。 操作流程 ...
spark本地linux测试,【EALinux测试面试题】面试问题：Spark 和… - 看准网
weixin_39928648的博客
05-12 189
Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties18/06/20 11:36:08 INFO SparkContext: Running Spark version 2.3.118/06/20 11:36:08 WARN NativeCodeLoader: Unable to load n...
[spark学习] spark rdd详解
最新发布
06-28
### 回答1： Spark RDD（弹性分布式数据集）是Spark中最基本的数据结构之一，它是一个不可变的分布式对象集合，可以在集群中进行并行处理。RDD可以从Hadoop文件系统中读取数据，也可以从内存中的数据集创建。RDD支持两种类型的操作：转换操作和行动操作。转换操作是指对RDD进行转换，生成一个新的RDD，而行动操作是指对RDD进行计算并返回结果。RDD具有容错性，因为它们可以在节点之间进行复制，以便在节点故障时恢复数据。 Spark RDD的特点包括： 1. 分布式：RDD可以在集群中进行并行处理，可以在多个节点上进行计算。 2. 不可变性：RDD是不可变的，一旦创建就不能修改，只能通过转换操作生成新的RDD。 3. 容错性：RDD具有容错性，因为它们可以在节点之间进行复制，以便在节点故障时恢复数据。 4. 惰性计算：RDD的计算是惰性的，只有在行动操作时才会进行计算。 5. 缓存：RDD可以缓存到内存中，以便在后续操作中快速访问。 Spark RDD的转换操作包括： 1. map：对RDD中的每个元素应用一个函数，生成一个新的RDD。 2. filter：对RDD中的每个元素应用一个函数，返回一个布尔值，将返回值为true的元素生成一个新的RDD。 3. flatMap：对RDD中的每个元素应用一个函数，生成一个新的RDD，该函数返回一个序列，将所有序列中的元素合并成一个新的RDD。 4. groupByKey：将RDD中的元素按照key进行分组，生成一个新的RDD。 5. reduceByKey：将RDD中的元素按照key进行分组，并对每个分组中的元素进行reduce操作，生成一个新的RDD。 Spark RDD的行动操作包括： 1. count：返回RDD中元素的个数。 2. collect：将RDD中的所有元素收集到一个数组中。 3. reduce：对RDD中的所有元素进行reduce操作，返回一个结果。 4. foreach：对RDD中的每个元素应用一个函数。 5. saveAsTextFile：将RDD中的元素保存到文本文件中。 以上就是Spark RDD的详细介绍。 ### 回答2： Apache Spark是一款基于内存的分布式计算系统，可以处理大规模数据，其中最为重要的就是Spark中的RDD（Resilient Distributed Datasets，弹性分布式数据集），RDD是Spark中的基本数据结构，是一种类似于数组的分布式数据集，可以被分割成多个分区，并在集群中的多个节点间进行并行计算。RDD是Spark提高执行效率和数据可靠性的重要手段。 在Spark中，RDD具有以下三个特点：弹性、不可变和可分区。弹性指RDD能够自动进行数据分区和容错，即使节点出现故障，也能够自动从故障的节点中复制数据，提高了数据的可靠性和并行计算的效率。不可变指RDD一旦创建就不能够被改变，可以进行转换操作生成新的RDD，也可以被缓存到内存中以供重复使用。可分区则指RDD中可以被分成多个分区，实现并行计算。 Spark中RDD的API提供了丰富的操作方法，常见的操作包括：转换操作和动作操作。转换操作指对RDD进行转换操作，返回一个新的RDD对象，例如map()、filter()等；动作操作指对RDD进行计算并返回结果，例如reduce()、collect()等。 值得注意的是，RDD是一种惰性求值的数据结构，即当对RDD进行转换操作时并不会立即进行计算，而是当需要对RDD进行动作操作时才会进行计算，这种惰性求值的机制可以进一步提高Spark的效率。同时，为了提高计算效率，可以使用RDD的持久化（缓存）功能，将RDD持久化到内存中，以便复用。 总之，RDD是Spark中的核心数据结构，其弹性、不可变和可分区的特点以及丰富的API操作方法，为Spark实现高效计算和数据处理提供了重要的支持。 ### 回答3： Spark RDD是Spark的核心抽象，代表分布式的元素集合，支持多种操作和转换。RDD可以看作是一个不可变的分布式内存数据集合，由一些分布式的partition(分区)组成。 1. RDD的特性： - 分布式的数据集，可以跨越多个节点进行计算 - 可以并行处理，充分利用集群计算资源 - 不可变的数据集，任何对数据集的操作都会生成新的数据集 - 支持多种类型的转换操作，如map、filter、reduce、groupByKey等 2. RDD的创建： - 通过外部数据源创建RDD：从HDFS或其他存储系统中读取数据创建 - 通过程序中的数据结构创建RDD：从内存中的数据结构中创建 - 通过其他RDD转换创建RDD：通过对已有的RDD进行转换操作创建 3. RDD的转换： RDD支持多种类型的操作和转换，如map、filter、reduce、groupByKey等。这些转换操作不会立即执行，而是记录下来，等到需要输出结果时才会真正执行。 4. RDD的行动： 行动操作是指对RDD进行计算并返回结果的操作，如count、collect等。行动操作会立即触发RDD的计算过程。 5. RDD的缓存： RDD支持缓存操作，将一个RDD的结果缓存在内存中，提高后续对该RDD的计算效率。缓存可以在计算过程中多次使用，通过unpersist清理缓存。 6. RDD的持久化： 当RDD的计算过程非常复杂时，可以将计算过程中得到的RDD进行持久化以便后续使用。持久化可以选择将RDD保存在磁盘中或者内存中，也可以将RDD复制到多个节点上以保障数据的可靠性。 7. RDD的checkpoint： RDD的checkpoint是指将RDD的计算结果保存在HDFS或其他分布式存储系统中，以便后续查询和还原数据集。在计算复杂的RDD时，使用checkpoint可以避免计算过程中数据丢失的问题。 总的来说，Spark RDD是Spark分布式计算的核心特性，其提供对大规模数据集的分布式处理能力，以及丰富的操作和转换方式，使得程序员可以轻松地处理海量数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值