Spark常用算子-action

spark action常用算子类型如下：
1.collectAsMap(): Map[K, V]：二元组RDD转为Map数据类型
countByKey(): Map[K, Long]：统计RDD中每个key出现的次数，还回Map类型表示每个key出现了几次
countByValue(): Map[T, Long]：统计RDD中每个元素出现的次数，还回Map类型表示每个元素出现了几次

val rdd2: RDD[(String, Int)] = sc.parallelize(List(("a", 21), ("b", 2), ("c", 3), ("a", 3), ("d", 21), ("e", 21)), 2)
// action: collectAsMap
val kv: Map[String, Int] = rdd2.collectAsMap()
println(kv)
// countByKey
val keyCount = rdd2.countByKey()
println(keyCount)
// countByValue
val valueCount = rdd2.countByValue()
println(valueCount)

/**
Map(e -> 21, b -> 2, d -> 21, a -> 3, c -> 3)
Map(e -> 1, a -> 2, b -> 1, c -> 1, d -> 1)
Map((c,3) -> 1, (b,2) -> 1, (e,21) -> 1, (a,3) -> 1, (a,21) -> 1, (d,21) -> 1)
*/

2.foreach(f: T => Unit): Unit：循环遍历RDD中每一个元素
foreachPartition(f: Iterator[T] => Unit): Unit：该算子与foreach算子类似，遍历处理元素数据时可共享分区内资源，当需要额外对象数据时foreachPartition算子比foreach效率高。

val rdd = sc.parallelize(List(1, 2, 3, 4, 5, 6), 2)
rdd.foreach(println(_))
rdd.foreachPartition { iterator =>
    val value = { //外连接资源 }
    println(value+iterator.reduce(_*_))
}

3.aggregate [U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U：算子中参数zeroValue是初始值；seqOp是分区内Task的执行逻辑，在分区内zeroValue与第一个元素按业务逻辑聚集再依次与剩余元素聚集，还回与zeroValue同样数据类型；combOp是聚集各分区的业务逻辑操作，起始也是由zeroValue与第一个分区聚集结果按业务逻辑聚集，再依次与剩余分区聚集结果依次聚集，输入与输出数据类型都与zeroValue一致。

  /**
    * 分区内初始值zeroValue与每个元素依次聚集
    *
    * @param zeroValue
    * @param value
    * @return
    */
  def seqOp(zeroValue: ArrayBuffer[Int], value: Int): ArrayBuffer[Int] = {
    println("zeroValue:" + zeroValue + "\tvalue:" + value)
    zeroValue += value
  }

  /**
    * 各个分区聚集后的结果再依次聚集
    *
    * @param a
    * @param b
    * @return
    */
  def combOp(a: ArrayBuffer[Int], b: ArrayBuffer[Int]): ArrayBuffer[Int] = {
    println("a:" + a + "\tb:" + b)
    a ++ b
  }
val rdd = sc.parallelize(List(1, 2, 3, 4, 5, 6), 2)
val result = rdd.aggregate(ArrayBuffer[Int](88))(seqOp, combOp)
println("------------------------------------")
println(result)

/**
结果如下：
zeroValue:ArrayBuffer(88)	value:1
zeroValue:ArrayBuffer(88, 1)	value:2
zeroValue:ArrayBuffer(88, 1, 2)	value:3
zeroValue:ArrayBuffer(88)	value:4
zeroValue:ArrayBuffer(88, 4)	value:5
zeroValue:ArrayBuffer(88, 4, 5)	value:6
a:ArrayBuffer(88)	b:ArrayBuffer(88, 1, 2, 3)
a:ArrayBuffer(88, 88, 1, 2, 3)	b:ArrayBuffer(88, 4, 5, 6)
------------------------------------
ArrayBuffer(88, 88, 1, 2, 3, 88, 4, 5, 6)
说明：zeroValue先在每个分区与元素依次聚集，zeroValue再与各个分区结果依次聚集，故2个分区结果有3个88
*/

 

未完待续