Spark-RDD行动算子、累加器、广播变量学习总结

RDD行动算子

1、reduce

聚合

2、Collect

将RDD内的数据取出 存入数组中   常用于  输出

3、Count

求和

4、First

返回RDD中的第一个元素

5、Take

  取出RDD中的前n个元素

6、takeOrdered

   先排序  然后取出前n个元素

7、Aggregate 分区聚合

/**

     * aggregate

     * aggregate(zeroValue: U)(seqOp: (U, V) => U,combOp: (U, U) => U)

     * zeroValue 初始值

     *  (U, V) => U 分区内的聚合逻辑

     *  combOp: (U, U) => U 分区间的处理逻辑

      */

例子  求平均值   

 val value = list.aggregate((0, 0))((x, y) =>

(x._1 + y, x._2 + 1), (n, m) => (n._1 + m._1, n._2 + m._2))

Var pj = value._1*1.0/value._2

8、Fold

  Aggregate简化版    分区内和分区外计算规则相同时使用

9、countByKey

 对key 进行计数

10、Save

//保存为txt文件

    rdd.saveAsTextFile("output")

// 序列化成对象保存到文件

rdd.saveAsObjectFile("output1")

11、foreach

 遍历循环

累加器 广播变量

累加器

val rdd = sc.makeRDD(List(1,2,3,4,5))

// 声明累加器

var sum = sc.longAccumulator("sum");

rdd.foreach(

num => {

// 使用累加器

sum.add(num)

}

)

// 获取累加器的值

println("sum = " + sum.value)

自定义累加器

// 1. 继承 AccumulatorV2，并设定泛型

// 2. 重写累加器的抽象方法

class WordCountAccumulator extends AccumulatorV2[String,

mutable.Map[String, Long]]{

var map : mutable.Map[String, Long] = mutable.Map()

// 累加器是否为初始状态

override def isZero: Boolean = { map.isEmpty

}

// 复制累加器

override def copy(): AccumulatorV2[String, mutable.Map[String, Long]] =

{ new WordCountAccumulator

}

// 重置累加器

override def reset(): Unit = { map.clear()

}

// 向累加器中增加数据 (In)

override def add(word: String): Unit = {

// 查询 map 中是否存在相同的单词

// 如果有相同的单词，那么单词的数量加 1

// 如果没有相同的单词，那么在 map 中增加这个单词

map(word) = map.getOrElse(word, 0L) + 1L

}

// 合并累加器

override def merge(other: AccumulatorV2[String, mutable.Map[String,

Long]]): Unit = {

val map1 = map

val map2 = other.value

// 两个 Map 的合并

map = map1.foldLeft(map2)( ( innerMap, kv ) => {

innerMap(kv._1) = innerMap.getOrElse(kv._1, 0L) + kv._2 innerMap

}

)

}

// 返回累加器的结果 （Out）

override def value: mutable.Map[String, Long] = map

广播变量

val rdd1 = sc.makeRDD(List( ("a",1), ("b", 2), ("c", 3), ("d", 4) ),4)

val list = List( ("a",4), ("b", 5), ("c", 6), ("d", 7) )

// 声明广播变量

val broadcast: Broadcast[List[(String, Int)]] = sc.broadcast(list)

val resultRDD: RDD[(String, (Int, Int))] = rdd1.map { case (key, num)

=> {

var num2 = 0

// 使用广播变量

for ((k, v) <- broadcast.value) { if (k == key) {

num2 = v

}

}

(key, (num, num2))

}

}