spark常用算子

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

/**
  * @author zoujc
  * @date 2018/10/31
  */
object LearnRDD {
   def main(args: Array[String]): Unit = {
      val sparkConf = new SparkConf().setAppName("SparkRDDTest").setMaster("local[2]")
      val sc = new SparkContext(sparkConf)

      //通过并行化，生成RDD
      val rdd1 = sc.parallelize(List(5,6,4,7,3,8,2,9,1,10))
      //对rdd1里面的每个元素*2后排序，true表示正序，false表示倒序
      val res1 = rdd1.map(_ * 2).sortBy(x => x, true)
      //过滤出大于等于10的元素
      val res2 = res1.filter(_ >= 10)

      val rdd2 = sc.parallelize(Array("a,b,c","d,e,f","g,h,i"))
      //对rdd2里的每个元素先切分再压平
      val res3 = rdd2.flatMap(_.split(","))

      val rdd3 = sc.parallelize(List(List("a b c","a b b"),List("e f g","a f g"),List("h i g","a a b")))
      //将rdd3的每个元素先切分在压平
      val res4 = rdd3.flatMap(_.flatMap(_.split(" ")))

      val rdd4 = sc.parallelize(List(5,6,4,3))
      val rdd5 = sc.parallelize(List(1,2,3,4))
      //求并集
      val res5 = rdd4.union(rdd5)
      //求交集
      val res6 = rdd4.intersection(rdd5)
      //去重
      val res7 = rdd4.union(rdd5).distinct()

      val rdd6 = sc.parallelize(List(("tom",1),("jerry",3),("kitty",2)))
      val rdd7 = sc.parallelize(List(("jerry",2),("tom",1),("shuke",2)))
      //求join
      val res8 = rdd6.join(rdd7)
      //求左连接、右连接
      val res9 = rdd6.leftOuterJoin(rdd7)
      val res10 = rdd6.rightOuterJoin(rdd7)
      //求并集，可以不用.union，也很强大
      val res11 = rdd6 union rdd7
      //按key分组
      val res12 = res11.groupByKey()

      //分别用groupByKey和reduceByKey实现单词计数，注意groupByKey与reduceByKey的区别
      //groupByKey
      val res13 = res11.groupByKey().mapValues(_.sum)
      /**
        * groupByKey:groupByKey会对每一个RDD中的value值进行聚合形成一个序列(Iterator)
        * 此操作发生在reduce端，所以势必所有的数据将会通过网络传输，造成不必要的浪费
        * 同时如果数据量十分大，可能还会造成OutOfMemoryError
        */

      //reduceByKey，先进行局部聚合，在进行全局聚合
      val res14 = res11.reduceByKey(_ + _)
      /**
        * reduceByKey:reduceByKey会在结果发送至reduce之前会对每个mapper在本地进行merge，
        * 有点类似于MapReduce中的combiner。这样做的好处是在map端进行一次reduce之后，
        * 数据量会大幅度减小，从而减小传输，保证reduce端能够更快的进行结果计算。
        */

      val rdd8 = sc.parallelize(List(("tom", 1), ("tom", 2), ("jerry", 3), ("kitty", 2)))
      val rdd9 = sc.parallelize(List(("jerry", 2), ("tom", 1), ("shuke", 2)))
      //cogroup ,注意cgroup与groupByKey区别
      val res15 = rdd8.cogroup(rdd9)
      /**
        * cogroup是将输入的数据集(k,v)和另外的数据集(k,w)进行cogroup，
        * 得到的数据集是(k,Seq(v),Seq(w))的数据集
        */
      val rdd10 = sc.parallelize(List(1, 2, 3, 4, 5))
      //reduce聚合  reduce是action类算子
      val res16 = rdd10.reduce(_ + _)

      val rdd11 = sc.parallelize(List(("tom", 1), ("jerry", 3), ("kitty", 2), ("shuke", 1)))
      val rdd12 = sc.parallelize(List(("jerry", 2), ("tom", 3), ("shuke", 2), ("kitty", 5)))
      val rdd13 = rdd11.union(rdd12)
      //按key进行聚合
      val res17 = rdd13.reduceByKey(_ + _)
      //按value的降序排序
      val res18 = rdd13.reduceByKey(_ + _).map(x => (x._2,x._1)).sortByKey(false).map(x => (x._2,x._1))

      /**
        * 笛卡尔积:    笛卡尔乘积是指在数学中，两个集合X和Y的笛卡尓积（Cartesian product），又称直积，
        * 表示为X×Y，第一个对象是X的成员而第二个对象是Y的所有可能有序对的其中一个成员[3]  。
        * 假设集合A={a, b}，集合B={0, 1, 2}，则两个集合的笛卡尔积为{(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}。
        */

      val res19 = rdd11.cartesian(rdd12)
      //要通过action类型的算子才能显示出结果，将结果放到可变数组中，就可以看到输出结果，
      //如果不加toBuffer，则打印出来的是一个引用。
//    println(res1.collect().toBuffer)
//    println(res2.collect().toBuffer)
//    ArrayBuffer(10, 12, 14, 16, 18, 20)
//    println(res3.collect().toBuffer)
//    println(res4.collect().toBuffer)
//    println(res5.collect().toBuffer)
//    println(res6.collect().toBuffer)
//    println(res7.collect().toBuffer)
//    ArrayBuffer(4, 1, 5, 6, 2, 3)
//    println(res8.collect().toBuffer)
//    println(res9.collect().toBuffer)
//    println(res10.collect().toBuffer)
//    res8.foreach(println)
//    res9.foreach(println)
//    res10.foreach(println)
//    println(res11.collect().toBuffer)
//    println(res12.collect().toBuffer)
//    println(res13.collect().toBuffer)
//    println(res14.collect().toBuffer)
//    println(res15.collect().toBuffer)
//    println(res16)
//    println(res17.collect().toBuffer)
//    println(res18.collect().toBuffer)
//    println(res19.collect().toBuffer)
   }
}