Spark-core：Spark RDD的高级算子

目录
    1.mapPartitionsWithIndex
    2.aggregate
    3.aggregateByKey:类似于aggregate操作，区别：操作的 的数据
    4.coalesce与repartition
    5.其他高级算子

1.mapPartitionsWithIndex

把每个partition中的分区号和对应的值拿出来

def mapPartitionsWithIndex[U](f: (Int, Iterator[T]) ⇒ Iterator[U])

(1)参数说明：

• f是一个函数参数，需要自定义。
• f 接收两个参数，第一个参数是Int，代表分区号。第二个Iterator[T]代表分区中的元素。

(2)通过这两个参数，可以定义处理分区的函数。

Iterator[U] ： 操作完成后，返回的结果。

(3)示例：将每个分区中的元素和分区号打印出来。

(a)

val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 3)

(b)创建一个函数返回RDD中的每个分区号和元素：

def func1(index:Int, iter:Iterator[Int]):Iterator[String] ={
   iter.toList.map( x => "[PartID:" + index + ", value=" + x + "]" ).iterator
}

(c )调用：

rdd1.mapPartitionsWithIndex(func1).collect

2.aggregate

含义：先对局部聚合，再对全局聚合

def aggregate[U](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)

举例：

(1)第一个例子：

val rdd1 = sc.parallelize(List(1,2,3,4,5), 2)

def func1(index:Int, iter:Iterator[Int]):Iterator[String] ={
   iter.toList.map( x => "[PartID:" + index + ", value=" + x + "]" ).iterator
}

//查看每个分区中的元素：
rdd1.mapPartitionsWithIndex(func1).collect

(a)需求：将每个分区中的最大值求和，注意：初始值是0；

//如果初始值为0，结果为7
rdd1.aggregate(0)(max(_,_),_+_)

//如果初始值为10，则结果为：30
rdd1.aggregate(10)(max(_,_),_+_)

(b)需求：如果是求和，注意：初始值是0：

//如果初始值是0
rdd1.aggregate(0)(_+_,_+_)

//如果初始值是10，则结果是：45
rdd1.aggregate(10)(_+_,_+_)

(2)第二个例子：一个字符串的例子：

val rdd2 = sc.parallelize(List("a","b","c","d","e","f"),2)

//修改一下刚才的查看分区元素的函数
def func2(index: Int, iter: Iterator[(String)]) : Iterator[String] = {
  iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
}

//查看两个分区中的元素：
rdd2.mapPartitionsWithIndex(func2).collect

运行结果：

rdd2.aggregate("")(_+_,_+_)

rdd2.aggregate("*")(_+_,_+_)

(3)例三：更复杂一点的例子

val rdd3 = sc.parallelize(List("12","23","345","4567"),2)

rdd3.mapPartitionsWithIndex(func2).collect

rdd3.aggregate("")((x,y) => math.max(x.length, y.length).toString, (x,y) => x + y)

程序执行分析：

第一个分区： "12"  "23"
    第一次比较："" 和 "12" 比，求长度的最大值: 2 。 2 ---> "2"
    第二次比较："2" 和 "23" 比，求长度的最大值: 2。 2 ---> "2"
				
第二个分区："345"  "4567"
    第一次比较："" 和 "345" 比，求长度的最大值: 3 。 3 ---> "3"
    第二次比较："3" 和 "4567" 比，求长度的最大值: 4。 4 ---> "4"

结果可能是：”24”，也可能是：”42”

(4)例四：

val rdd4 = sc.parallelize(List("12","23","345",""),2)

rdd4.mapPartitionsWithIndex(func2).collect

rdd4.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)

程序执行分析：

第一个分区： "12"  "23"
    第一次比较："" 和 "12" 比长度，求长度的最小值。 0 。 0 ---> "0"
    第二次比较："0" 和 "23" 比长度，求长度的最小值。 1。 1 ---> "1"
				
第二个分区："345"  ""
    第一次比较："" 和 "345" 比，求长度的最小值。 0 。 0 ---> "0"
    第二次比较："0" 和 "" 比，求长度的最小值。 0。 0 ---> "0"

结果是：”10”，也可能是”01”，

原因：注意有个初始值””，其长度0，然后0.toString变成字符串

(5)例5:

val rdd5 = sc.parallelize(List("12","23","","345"),2)

rdd5.mapPartitionsWithIndex(func2).collect

rdd5.aggregate("")((x,y) => math.min(x.length, y.length).toString, (x,y) => x + y)

结果是：”11”，原因同上

程序执行分析：

第一个分区： "12"  "23"
		第一次比较："" 和 "12" 比长度，求长度的最小值。 0 。 0 ---> "0"
		第二次比较："0" 和 "23" 比长度，求长度的最小值。 1。 1 ---> "1"
				
第二个分区：""  "345"
		第一次比较："" 和 "" 比，求长度的最小值。 0 。 0 ---> "0"
		第二次比较："0" 和 "345" 比，求长度的最小值。 1。 1 ---> "1"	

3.aggregateByKey:类似于aggregate操作，区别：操作的 的数据

(1)准备数据：

val pairRDD = sc.parallelize(List( ("cat",2), ("cat", 5), ("mouse", 4),("cat", 12), ("dog", 12), ("mouse", 2)), 2)

def func3(index: Int, iter: Iterator[(String, Int)]) : Iterator[String] = {
  iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
}

pairRDD.mapPartitionsWithIndex(func3).collect

(2)两个分区中的元素：

(3) 示例：

(a)将每个分区中的动物最多的个数求和

pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect

(b)将每种动物个数求和

pairRDD.aggregateByKey(0)(_+_, _ + _).collect

(c )这个例子也可以使用：reduceByKey

pairRDD.reduceByKey(_+_).collect

与reduceByKey相比，aggregateByKey 效率更高

4.coalesce与repartition

(1)都是将RDD中的分区进行重分区。

(2)区别是：coalesce默认不会进行shuffle(false)；而repartition会进行shuffle(true)，即：会将数据真正通过网络进行重分区。

(3)示例：

def func4(index: Int, iter: Iterator[(Int)]) : Iterator[String] = {
  iter.toList.map(x => "[partID:" +  index + ", val: " + x + "]").iterator
}

val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8,9), 2)

rdd1.mapPartitionsWithIndex(func4).collect

下面两句话是等价的：

val rdd2 = rdd1.repartition(3)

val rdd3 = rdd1.coalesce(3,true)    //--->如果是false，查看RDD的length依然是2

5、其他高级算子

参考：http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html