Spark高級算子練習（一）

package cn.allengao.exercise

import org.apache.spark.{SparkConf, SparkContext}

object SparkRDDTest2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkRDDTest2").setMaster("local")
    val sc = new SparkContext(conf)

    //指定爲2個分區
    val rdd1 = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7), 2)
    //設定一個函數，設定分區的ID索引，數值
    val func1 = (index: Int, iter: Iterator[(Int)]) => {
      iter.toList.map(x => "[partID:" + index + ", val: " + x + "]").iterator
    }


    //查看每個分區的信息
    val res1 = rdd1.mapPartitionsWithIndex(func1)

    //用aggregate，指定初始值，對rdd1進行聚合操作,先進行局部求和，再進行全局求和
    val res2 = rdd1.aggregate(0)(_ + _, _ + _)
    //將局部分區中最大的數找出來再進行求和
    val res3 = rdd1.aggregate(0)(math.max(_, _), _ + _)
    //每個分區都以10爲初始值，10用了3次
    val res4 = rdd1.aggregate(10)(_ + _, _ + _)

    /*
    運行結果：ArrayBuffer([partID:0, val: 1], [partID:0, val: 2],
    [partID:0, val: 3], [partID:1, val: 4], [partID:1, val: 5],
    [partID:1, val: 6], [partID:1, val: 7])
     */
    //    println(res1.collect().toBuffer)
    //運行結果：28
    //    println(res2)
    //運行結果：10
    //    println(res3)
    //運行結果：58
    //    println(res4)


    val rdd2 = sc.parallelize(List("a", "b", "c", "d", "e", "f"), 2)
    val res5 = rdd2.aggregate("|")(_ + _, _ + _)

    //運行結果：||abc|def
    //    println(res5)

    val rdd3 = sc.parallelize(List("12", "23", "345", "4567"), 2)
    //兩個分區先計算出字符串的最大長度，然後合成字符串
    val res6 = rdd3.aggregate("")((x, y) => math.max(x.length, y.length).toString, (x, y) => x + y)
    //運行結果：24 或者 42，體現了並行化的特點
    //    println(res6)

    val rdd4 = sc.parallelize(List("12", "23", "345", ""), 2)
    val res7 = rdd4.aggregate("")((x, y) => math.min(x.length, y.length).toString, (x, y) => x + y)
    //運行結果：01 或者 10，值"0".toString的長度爲0,"0".toString.length的長度爲1
    /*
    math.min("".length, "12".length ) 的結果是：0 , math.min("0".length, "23".length ) 的結果是：1
    math.min("".length, "345".length) 的結果是：0 , math.min("0".length, "".length) 的結果是：0
     */
    //    println(res7)

    val rdd5 = sc.parallelize(List("12", "23", "", "345"), 2)
    val res8 = rdd5.aggregate("")((x, y) => math.min(x.length, y.length).toString, (x, y) => x + y)
    //運行結果：11
    /*
    math.min("".length, "12".length ) 的結果是：0 , math.min("0".length, "23".length ) 的結果是：1
    math.min("".length, "".length) 的結果是：0 , math.min("0".length, "345".length) 的結果是：1
     */
    //        println(res8)

    //aggregateByKey可以先進行局部操作，再進行全局操作。
    val pairRDD = sc.parallelize(List(("cat", 2), ("cat", 5), ("mouse", 4), ("cat", 12), ("dog", 12), ("mouse", 2)), 2)

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

    //    println(pairRDD.mapPartitionsWithIndex(func2).collect.toBuffer)
    //把每種類型的最大的次數取出來
    //運行結果：ArrayBuffer((dog,12), (cat,17), (mouse,6))
    println(pairRDD.aggregateByKey(0)(math.max(_, _), _ + _).collect.toBuffer)
    //運行結果：ArrayBuffer((dog,12), (cat,22), (mouse,20))
    println(pairRDD.aggregateByKey(10)(math.max(_, _), _ + _).collect.toBuffer)
    /*
    pairRDD.aggregateByKey(0)(_ + _ , _ + _).collect與pairRDD.reduceByKey( _ + _).collect，
    這兩個方法執行結果是一樣的，實際上底層都是調用的同一個方法：combineByKey
     */


  }

}