spark 算子实例

RDD转换算子Transformation（lazy）:懒汉模式（转换）

一个数据集分成两个RDD，两个可能合并

map

输入变换函数应用于RDD中所有元素

val a = sc.parallelize(1 to 8)
val b = a.map(s=>(s+1))
b.collect

flatMap *输入变换函数应用于RDD中所有元素,将所有对象合并为一个对象。

sc.parallelize(1 to 10).flatMap(it=>it to 10).collect

filter

val a = sc.parallelize(1 to 9)
val b = a.filter(s=>(s%2==0))
b.collect

mapValues

在mapvalues上一个RDD中的Key不变与新的Values一起组成新的RDD

val a = sc.parallelize(List("aa","bb","cc","dd"))
val b=a.map(x=>(x.length,x))
b.mapValues("x"+_+"x").collect

MapPartitions

由于单独运行于RDD的每个分区上（block）,所以在一个类型为T的RDD上运行时，（fuction）必须时Iterator<>T=>Iterator类型的方法

val date=sc.parallelize(1 to 10,3)
def function(it:Iterator[Int]):Iterator[Int]={
   | var res = for(e <-it) yield e*2(yield相当缓冲)
   | res
   | }
val result4=data.mapPartitions(function)
result4.collect

sample(withReplacement,fraction,seed)

withReplacement:是否放回，fraction:采样比列，seed：随机数生成的种子
```
val date=sc.parallelize(1 to 10,3)
val result6=date.sample(false,0.5,1).collect
```
union()
对于元数据集和其他数据集求并集，不去重
```
value result7=date.union(result6)
result7.collect
```
intersection
对于元数据集和其他数据集求并集，去重
```
value result7=date.intersection(result6)
result7.collect
```
disinct
返回一个在源数据集去重之后的新数据集，即去重，并局部无序而整体有序返回
```
val date1=sc.parallelize(1 to 10,3)
val result=date1.disinct
result.collect
```
groupByKey

把键值对中相同的key值分组到一个集合序列中，其顺序是不确定 若一个键对应值太多，则易导致内存溢出。

val data=sc.parallelize(1 to 10)
val pair1=data.map(x=>{(x,1)})
val pair2=data.map(x=>{(x,2)})
val pair3=pair1.union(pair2)
val groupedPair=pair3.groupByKey
groupedPair.collect

join

将相同的key值提取出来，value值形成（x,y）

val data=sc.parallelize(1 to 10)
val pair1=data.map(x=>{(x,1)})
val pair2=data.map(x=>{(x,2)})
val joinpair=pair1.join(pair2,2).collect

sortByKey(ascending,numTasks)

根据key来进行排序，默认true升序

val data=sc.parallelize(1 to 10)
val pair1=data.map(x=>{(x,1)})
val pair2=data.map(x=>{(x,2)})
val pair3=pair1.union(pair2)
val sortPair=pair3.sortByKey(true,2)
sortPair=pair3.sortByKey(false,2)

RDD动作算子Action（non-lazy）：饿汉模式（行动）

根据多个RDD转换返回的都是具体的值

reduce

将RDD中的元素两两传递，同时产生一个新值

val data=sc.parallelize(1 to 10)
data.reduce((a,b)=>a+b)//方法一
data.reduce(_+_)//方法二

take()

取第几个值

val data = sc.parallelize(1 to 10)
data.take(2)
//结果
res17: Array[Int] = Array(1, 2)

猜你喜欢