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)