Spark知识汇总

flatMap和Map区别

map,(1对1) ，将一个结果转化为另一个结果

ArrayBuffer(0)
ArrayBuffer(0, 1)
ArrayBuffer(0, 1, 2, 3)
ArrayBuffer(0, 1, 2, 3, 4)
ArrayBuffer(0, 1, 2)


flatMap （1对多），将一个结果转化为多个结果 。会将聚合数组切分
0 0 1 0, 1, 2, 3，0, 1, 2, 3, 4 0, 1, 2
==============================================================
val rdd = sparkContext.makeRDD(Array(1,2,3,4,5))
    val ressList = rdd.map {
      case (item) =>
        val list = new ArrayBuffer[Int]()
        for (i <- 0 until item) {
          list += i;
        }
        list
    }
    ressList.foreach(println(_))

Key值

如果想要使用 sortByKey groupByKey reduceByKey

那么必须将数据转为 Tuple2(key,value)
  
下标一默认为Key

groupBykey和groupBy区别

groupByKey  ,将value聚合在一起
(1,CompactBuffer(1, 1, 1, 1))
(4,CompactBuffer(4))
(0,CompactBuffer(0, 0, 0, 0, 0))
(3,CompactBuffer(3, 3))
(2,CompactBuffer(2, 2, 2))

groupBy ,将整个结构聚合在一起

(4,CompactBuffer((4,4)))
(2,CompactBuffer((2,2), (2,2), (2,2)))
(3,CompactBuffer((3,3), (3,3)))
(1,CompactBuffer((1,1), (1,1), (1,1), (1,1)))
(0,CompactBuffer((0,0), (0,0), (0,0), (0,0), (0,0)))
============================================================
val rdd = sparkContext.makeRDD(Array(1,2,3,4,5))
    val ressList = rdd.flatMap {
      case (item) =>
        val list = new ArrayBuffer[(Int,Int)]()
        for (i <- 0 until item) {
          list+=((i,i))
        }
        list
    }
    ressList.groupBy(_._1).foreach(println(_))
    println("=====")
    ressList.groupByKey().foreach(println(_))

reduceByKey 和 reduce 区别

reduceByKey : 根据key将value 聚合加起来，

(4,4)
(3,6)
(1,4)
(2,6)
(0,0)

reduceBy  : 将整个数据聚合起来，只有 一个值

(20,20)
=============================================================
val rdd = sparkContext.makeRDD(Array(1,2,3,4,5))
    val ressList = rdd.flatMap {
      case (item) =>
        val list = new ArrayBuffer[(Int,Int)]()
        for (i <- 0 until item) {
          list+=((i,i))
        }
        list
    }
ressList.reduceByKey( (a,b)=> a+b   ).foreach(println(_))
println(ressList.reduce((a, b) => (a._1 + b._1, a._2 + b._2))) //只有一个值，只能打印

take() 和 makeRDD区别

take:  从RDD拿 N个数据，返回类型是 Array 。所有数据都在一起
(0,0)
(0,0)
(1,1)
(0,0)
(1,1)
(2,2)
(0,0)
(1,1)
(2,2)
(3,3)
makeRDD: 将Array里的数据，转为RDD类型  。所有数据在不同的分区
(0,0)
(0,0)
2021-02-05 13:28:57,449   INFO --- [ 
(2,2)
(0,0)
2021-02-05 13:28:57,451   INFO --- [ 
==============================================================
val rdd = sparkContext.makeRDD(Array(1,2,3,4,5))
    val ressList = rdd.flatMap {
      case (item) =>
        val list = new ArrayBuffer[(Int,Int)]()
        for (i <- 0 until item) {
          list+=((i,i))
        }
        list
    }
    val top10 :Array[(Int,Int)]  = ressList.take(10)
    val rdd10 : RDD[(Int,Int)]= sparkSession.sparkContext.makeRDD(top10)
    top10.foreach(println(_))
    rdd10.foreach(println(_))

DStream和RDD区别

在DStream中。一个batchInterval/时间窗口 产生且仅仅产生一个RDD。如果在这个时间间隔内，那么DStreaming仍然会对应1个RDD，不过这个RDD没有元素，即调用RDD.isEmpty为true。

当一个新的时间窗口（batchInterval)开始时，此时产生一个空的block，此后在这个窗口内接受到的数据都会累加到这个block上，当这个时间窗口结束时，停止累加，这个block对应的数据就是
这个时间窗口对应的RDD包含的数据

DStream 里的结构是 Key：value。 key:时间窗口，value 为RDD.

每次对DStream操作，直接是对RDD的操作.


DStream有多个时间窗口的RDD的，所有要 foreachRDD()

 

SparkStreaming中，transform和 map区别

// TODO Driver端执行 1次
    lineStreams.transform {
      rdd:RDD[String]  =>  // 类型是RDD
                          //TODO Driver端执行，每周期一次。因为 
        println("  transform be executed ")
        rdd
      }.print()


/


// TODO Drvier端 执行一次
   lineStreams.map{
      rdd :String =>             // 类型是String
                                //TODO  Executor端执行 n 次
        println(" execute map ")
        rdd
    }.print()
///
// TODO 两个结合使用
lineStreams.transform{
      rdd=>
        //TODO Driver执行，负责每次周期更新数据
        rdd.map{
           _  //TODO Executor端执行，负责具体数据
        }
    }