Spark之RDD编程

原创 2016年08月28日 23:56:32

RDD,全称Resilient Distributed
Datasets(弹性分布式数据集),是Spark最为核心的概念,是Spark对数据的抽象。RDD是分布式的元素集合,每个RDD只支持读操作,且每个RDD都被分为多个分区存储到集群的不同节点上。除此之外,RDD还允许用户显示的指定数据存储到内存和磁盘中,掌握了RDD编程是SPARK开发的第一步。

1.RDD读取数据

文件读取

scala> val lines = sc.textFile("README.md")
scala> lines.collect()

并行化读取

scala> var lines = sc.parallelize(List("i love you"))
scala> lines.collect()

2.RDD操作之transformation

RDD的操作可分两种:
1 转化操作(transformation) : 由一个RDD生成一个新的RDD
2 行动操作(action) : 对RDD中的元素进行计算,并把结果返回
参考api: org.apache.spark.rdd.RDD
3.下划线用法

//以下两句等同
_.split(" ")
line => line.split(" ")
//等同
_ + _
(left, right) => left + right

2.1.map()

返回:一个新的RDD

scala> val rdd = sc.parallelize(List(1,2,3,3))
scala> val rrr=rdd.map(x => x +1 )
scala> rrr.collect()
        Array[Int] = Array(2, 3, 4, 4)
scala> rrr.foreach(println)
2
4
4
3

2.2.flatmap()

返回:迭代器的所有元素组成一个新的RDD

val rdd1 = sc.parallelize(List(1,2,3,3))
scala> rdd1.map(x=>x+1).collect
       Array[Int] = Array(2, 3, 4, 4)
scala> rdd1.flatMap(x=>x.to(3)).collect
       Array[Int] = Array(1, 2, 3, 2, 3, 3, 3)

从上面可以看出flatMap先map然后再flat

2.3.filter()

对每个元素进行筛选,返回符合条件的元素组成的一个新RDD

scala> val rdd = sc.parallelize(List(1,2,3,3))
scala> rdd.filter(x => x != 1).collect()
     Array[Int] = Array(2, 3, 3)

两变量过滤操作

scala> val rdd = sc.parallelize(List((1,2),(3,4),(3,6)))

对value做控制,key不加限制条件

scala> val result = rdd.filter{case(x,y)=>y%3==0}
scala> result.foreach(println)
(3,6)
scala> val result = rdd.filter{case(x,y)=>y<=4}
scala> result.foreach(println)
(1,2)
(3,4)

对key做控制,value不控制

scala> val result = rdd.filter{case(x,y)=>x<3}
scala> result.foreach(println)
(1,2)

2.4 distinct()

distinct() : 去掉重复元素

scala> rdd.distinct().collect()
      Array[Int] = Array(1, 2, 3)

2.5 sample(withReplacement,fration,[seed])

sample():对RDD采样

  • 第一个参数如果为true,可能会有重复的元素,如果为false,不会有重复的元素;
  • 第二个参数取值为[0,1],最后的数据个数大约等于第二个参数乘总数;
  • 第三个参数为随机因子。
 scala> rdd.sample(false,0.5).collect()
     Array[Int] = Array(3, 3)

scala> rdd.sample(false,0.5).collect()
     Array[Int] = Array(1, 2)

scala> rdd.sample(false,0.5,10).collect()
    Array[Int] = Array(2, 3)

2.6排序

rdd.sortByKey():返回一个根据键排序的RDD

数据排序,可以通过接受ascending的参数表示我们是否想要结果按升序排序(默认是true)

scala> val result = rdd.sortByKey().collect()
          Array[(Int, Int)] = Array((1,2), (3,4), (3,6))

2.7reduce

rdd.reduceByKey(func):合并具有相同key的value值

scala> val rdd = sc.parallelize(List((1,2),(3,4),(3,6)))
scala> val result = rdd.reduceByKey((x,y)=>x+y)
scala> result.foreach(println)
(1,2)
(3,10)

2.8group

rdd.groupByKey():对具有相同键的进行分组 [数据分组]

scala> val result = rdd.groupByKey()
scala> result.foreach(println)
       (3,CompactBuffer(4, 6))
       (1,CompactBuffer(2))

2.9 mapValues

rdd.mapValues(func):对pairRDD中的每个值应用func 键不改变

scala> val rdd = sc.parallelize(List((1,2),(3,4),(3,6)))
scala> val result = rdd.mapValues(x=>x+1)
scala> result.foreach(println)
(1,3)
(3,5)
(3,7)

3.针对两个pair RDD 的转化操作

3.1 rdd.subtractByKey( other )

删除掉RDD中与other RDD中键相同的元素

scala> val rdd = sc.parallelize(List((1,2),(3,4),(3,6)))
scala> val other = sc.parallelize(List((3,9)))
scala> val result = rdd.subtractByKey(other)
scala> result.foreach(println)
(1,2)

3.2 join内连接

rdd,other是3.1的变量

scala> val result = rdd.join(other)
scala> result.foreach(println)
(3,(4,9))
(3,(6,9))

3.3 右外连接

rdd,other是3.1的变量

scala> val result = rdd.rightOuterJoin(other)
scala> result.foreach(println)
     (3,(Some(4),9))
     (3,(Some(6),9))

3.4 左外连接

scala> val result = rdd.leftOuterJoin(other)
scala> result.foreach(println)
   (3,(4,Some(9)))
   (3,(6,Some(9)))
   (1,(2,None))

3.5按相同键分组

scala> val result = rdd.cogroup(other)
scala> result.foreach(println)
(1,(CompactBuffer(2),CompactBuffer()))
(3,(CompactBuffer(4, 6),CompactBuffer(9)))

3.6 使用reduceByKey()和mapValues()计算每个键对应累加值

x._1表示取元组的第一个值

scala> val rdd = sc.parallelize(List(Tuple2("panda",0),Tuple2("pink",3),Tuple2("pirate",3),Tuple2("panda",1),Tuple2("pink",4)))
scala> val result = rdd.mapValues(x=>(x,1)).reduceByKey((x,y)=>(x._1+y._1,x._2+y._2))
scala> result.foreach(println)
(pirate,(3,1))
(panda,(1,2))
(pink,(7,2))

3.7计单词(wordcount)

用map reduce实现:

scala> val rdd = sc.parallelize(List("i am thinkgamer, i love cyan"))
scala> val words = rdd.flatMap(line => line.split(" "))
scala> val result = words.map(x=>(x,1)).reduceByKey((x,y) => x+y)
scala> result.foreach(println)
(cyan,1)
(love,1)
(thinkgamer,,1)
(am,1)
(i,2)

用countByValue实现:

scala> val rdd = sc.parallelize(List("i am thinkgamer, i love cyan"))
scala> val result = rdd.flatMap(x=>x.split(" ")).countByValue()
scala> result.foreach(println)
(am,1)
(thinkgamer,,1)
(i,2)
(love,1)
(cyan,1)

4.RDD操作之action

下面例子以 val rdd = sc.parallelize(List(1,2,3,3))为输入

4.1 collect()返回所有元素

scala> rdd.collect()
       Array[Int] = Array(1, 2, 3, 3)

4.2 count() :返回元素个数

scala> rdd.count()
         Long = 4

4.3 countByValue() : 各个元素出现的次数

scala> rdd.countByValue()
     scala.collection.Map[Int,Long] = Map(1 -> 1, 2 -> 1, 3 -> 2)

4.4 take(num) : 返回num个元素

scala> rdd.take(2)
       Array[Int] = Array(1, 2)

4.5 top(num) : 返回前num个元素

scala> rdd.top(2)
         Array[Int] = Array(3, 3)

4.6 foreach(func):对每个元素使用func

scala> rdd.foreach(x => println(x*2))
版权声明:本文为博主原创文章,未经博主允许不得转载。

Spark RDD编程(Python和Scala版本)

Spark中的RDD就是一个不可变的分布式对象集合,是一种具有兼容性的基于内存的集群计算抽象方法,Spark则是这个方法的抽象。        Spark的RDD操作分 和为转化操作(transf...
  • Gamer_gyt
  • Gamer_gyt
  • 2016年06月18日 11:08
  • 5902

Spark 的键值对(pair RDD)操作,Scala实现

一:什么是Pair RDD?          Spark为包含键值对对类型的RDD提供了一些专有操作,这些操作就被称为Pair RDD,Pair RDD是很多程序的构成要素,因为它们提供了并行操作对...
  • Gamer_gyt
  • Gamer_gyt
  • 2016年07月04日 15:52
  • 8860

spark RDD算子(二) filter,map ,flatMap

spark算子二 filter,map ,flatMap 实战入门,spark2.0 和 spark1.6中的flatMap区别 iterator
  • T1DMzks
  • T1DMzks
  • 2017年04月16日 21:34
  • 4332

Spark算子:RDD创建操作

关键字:Spark RDD 创建、parallelize、makeRDD、textFile、hadoopFile、hadoopRDD、newAPIHadoopFile、newAPIHadoopRDD ...
  • wisgood
  • wisgood
  • 2016年09月26日 13:57
  • 743

Spark算子:RDD基本转换操作(4)–union、intersection、subtract

关键字:Spark算子、Spark RDD基本转换、union、intersection、subtract union def union(other: RDD[T]): RDD[T] 该函数比较简单...
  • ljp812184246
  • ljp812184246
  • 2016年12月27日 13:44
  • 2326

Spark总结(二)——RDD的Transformation操作

1、创建RDD的两种方式: (1)、从HDFS读入数据产生RDD; (2)、有其他已存在的RDD转换得到新的RDD;scala> val textFile = sc.textFile("hdfs:...
  • zzh118
  • zzh118
  • 2016年07月22日 20:23
  • 1726

Spark 的键值对(pair RDD)操作,Scala实现

一:什么是Pair RDD?          Spark为包含键值对对类型的RDD提供了一些专有操作,这些操作就被称为Pair RDD,Pair RDD是很多程序的构成要素,因为它们提供了并行操作对...
  • Gamer_gyt
  • Gamer_gyt
  • 2016年07月04日 15:52
  • 8860

Spark RDD基本操作

Spark RDD Scala语言编程RDD(Resilient Distributed Dataset)是一个不可变的分布式对象集合, 每个rdd被分为多个分区, 这些分区运行在集群的不同节点上。r...
  • wusuopuBUPT
  • wusuopuBUPT
  • 2016年11月13日 20:32
  • 3087

spark大数据入门(三)--RDD的简单解析

什么是RDD      RDD是弹性分布式数据集的简称,她具有以下的优点:第一RDD具有并行化的操作特点,通俗的说,在RDD中存在一定数量的分片,每一个分片都会对应一个task,这些Task是可以并发...
  • liyaohhh
  • liyaohhh
  • 2015年12月11日 12:31
  • 1863

Spark核心RDD:Sort排序详解

1.sortByKey 无可非议sortByKey是Spark的最常用的排序,简单的案例暂且跳过,下面给一个非简单的案例,让我进入排序之旅 对下面简单元祖,要求先按元素1升序,若元素1相同,则按元素3...
  • jiangpeng59
  • jiangpeng59
  • 2016年10月26日 23:27
  • 9307
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Spark之RDD编程
举报原因:
原因补充:

(最多只允许输入30个字)