Spark算子及其分类总结

桃扇骨 2023-09-27 18:49 1阅读 0赞

**目录**

transform：

窄依赖：

map

map\_1

mapPartitions

mapPartitions\_Test

mapPartitionsWithIndex

mapPartitionsWithIndex\_1

flatMap

flatMap\_1

flatMap\_2

glom

glom\_Test

groupBy

groupBy\_1

filter

sample

宽依赖：

distinct

coalesce

repartition

sortBy

sortBy\_1

双value类型：intersection、substract

Key-value类型：

partitionBy

reduceByKey

groupByKey

aggregateByKey

foldByKey

combineByKey

join

leftOuterJoin、rightOuterJoin

cogroup

action：

collect

reduce、count、first、take、takeOrdered

aggregate、fold

countByValue、countByKey

foreach

--------------------

# transform： #

转换算子，功能的补充和封装，将旧的RDD包装成新的RDD

## 窄依赖： ##

### map ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - map : map 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是指的转换
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark01_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - map
        //需求：将1,2,3,4 转换成2,4,6,8
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
    
        //转换函数
        def mapFunction(num:Int): Int = {
          num * 2
        }
    
        val mapRDD: RDD[Int] = rdd.map(mapFunction)
        //    rdd.map((num:Int) => {num*2})//map中需要传入一个函数，可以是声明好的函数，也可以是匿名函数
        //    rdd.map((num:Int) => num*2)//匿名函数中如果只有一句方法体的话，可以省略花括号{}
        //    rdd.map(num => num*2)//匿名函数中如果只有一个参数的话，可以去掉括号（）
        val mapRDD1: RDD[Int] = rdd.map(_ * 2) //匿名函数中参数只被使用一次的话，可以用下划线_代替
    
        //collect是行动算子，只有触发行动算子才会进行任务的调度和作业的执行
        mapRDD.collect().foreach(println)
        mapRDD1.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### map\_1 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - map : map 将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是指的转换
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark01_RDD_Operator_Transform_par {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - map
        //需求：测试不同分区之间的执行顺序，并行执行规律
    
        /**
         * 1. rdd的计算一个分区内的数据是一个一个按顺序执行逻辑
         *    只有前面一个数据全部的逻辑都执行完毕之后，才会执行下一个数据
         *    分区内数据的执行是有序的。
         * 2. 不同分区之间的数据计算是无序的。不同分区间是并行执行的，所以没有先后顺序。
         */
        //    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 1)
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
    
        val mapRDD: RDD[Int] = rdd.map {
          num => {
            println("--------------" + num)
            num
          }
        }
        val mapRDD1: RDD[Int] = mapRDD.map {
          num => {
            println("###############" + num)
            num
          }
        }
    
        mapRDD1.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### mapPartitions ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - mapPartitions : mapPartitions 将待处理的数据以分区为单位发送到计算结点进行处理
    // ，这里的处理是指可以进行任意的处理，哪怕是过滤数据。
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark02_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - mapPartitions
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
    
        /**
         * mapPartitions : 可以以分区为单位进行数据转换的操作，就不会像map中一条一条处理，类似于IO中的缓存流
         *                  但是会将整个分区的数据加载到内存进行引用
         *                  处理完的数据是不会被释放掉，存在对象的引用。
         *                  在内存较小，数据量较大的情况下，容易出现内存溢出。
         *                  所以要适当的选择 map 还是mapPartitions
         */
        val mapRDD: RDD[Int] = rdd.mapPartitions(
          iter => {
            println("############")
            iter.map(_*2)//iter是个迭代器，不是参数，每个分区一个iter迭代器，所以要调用方法才能进行逻辑处理
          }
        )
    
        mapRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### mapPartitions\_Test ###

### mapPartitionsWithIndex ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - mapPartitionsWithIndex : mapPartitionsWithIndex 将待处理的数据以分区为单位发送到计算结点进行处理
    // ，这里的处理是指可以进行任意的处理，哪怕是过滤数据,在处理时可以获取当前分区索引，指定分区。
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark03_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - mapPartitionsWithIndex
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
    
        //需求：过滤掉0号分区的数据，留下1号分区的数据
        val mpiRDD: RDD[Int] = rdd.mapPartitionsWithIndex(
          (index, iter) => {
            if (index == 1) { //如果是第二个分区
              iter //则保留迭代器
            } else {
              Nil.iterator //返回一个空的迭代器
            }
          }
        )
    
        mpiRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### mapPartitionsWithIndex\_1 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - mapPartitionsWithIndex : mapPartitionsWithIndex 将待处理的数据以分区为单位发送到计算结点进行处理
    // ，这里的处理是指可以进行任意的处理，哪怕是过滤数据,在处理时可以获取当前分区索引，指定分区。
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark03_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - mapPartitionsWithIndex
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))//你指定分区数，则表示按本机核数为分区树，这里是8核，所以是8个分区
    
        //需求：查看每个数据被分配到那个分区，返回形式为（分区号，数据）
        val mpiRDD = rdd.mapPartitionsWithIndex(
          (index, iter) => {
            iter.map(
              num => {
                (index, num)
              }
            )
          }
        )
    
        mpiRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### flatMap ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - flatMap :将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
    // 这里说的扁平化，就是将一个集合或者一个字符串等等拆分成一个一个的，比如list（1,2）就拆分成1，2
    // 扁平化：将整体拆分成个体
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark04_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - flatMap
    
        val rdd: RDD[List[Int]] = sc.makeRDD(List(List(1, 2), List(3, 4)))
    
        //需求：将list集合中的一个个的list集合元素，拆分成一个个的数据
        //如List(List(1, 2), List(3, 4)拆分成1,2,3,4
        val flatRDD: RDD[Int] = rdd.flatMap(
          list => {
            list
          }
        )
    
        rdd.collect().foreach(println)
        flatRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### flatMap\_1 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - flatMap :将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
    // 这里说的扁平化，就是将一个集合或者一个字符串等等拆分成一个一个的，比如list（1,2）就拆分成1，2
    // 扁平化：将整体拆分成个体
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark04_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - flatMap
    
        val rdd: RDD[String] = sc.makeRDD(List("Hello world","Hello Spark"))
    
        //需求：实现一个WordCount
        //将一个个的字符串，按照给定的功能进行划分，如这里是按空格进行划分成一个个的单词，这就叫扁平化
        val flatRDD = rdd.flatMap(
          s => {
            s.split(" ")
          }
        )
    
        flatRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### flatMap\_2 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - flatMap :将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
    // 这里说的扁平化，就是将一个集合或者一个字符串等等拆分成一个一个的，比如list（1,2）就拆分成1，2
    // 扁平化：将整体拆分成个体
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark04_RDD_Operator_Transform3 {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - flatMap
    
    
        val rdd: RDD[Any] = sc.makeRDD(List(List(1, 2), 3, List(4, 5)))
    
        //需求：当数据不是相同类型的时候，要进行扁平化处理，这时候就需要用到模式匹配了
        //如：这里的数据是List(1, 2), 3, List(4, 5)，要进行扁平化处理，所以用模式匹配来满足条件
        val flatRDD: RDD[Any] = rdd.flatMap(
          datas => {
            datas match {
              case list: List[_] => list
              case data => List(data)
            }
          }
        )
    
        flatRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### glom ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - glom : 将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变，不需要传递参数
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark05_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - glom
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
        //makeRDD : List => Int
        //glom    : Int  => Array
    
        //需求：将Int类型的数据转为Int类型的数组，按分区间来转换，分区内数据不变
        val glomRDD: RDD[Array[Int]] = rdd.glom()
    
        //每个数组内的数据以逗号分隔打印
        glomRDD.collect().foreach(data => println(data.mkString(",")))
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### glom\_Test ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - glom : 将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变，不需要传递参数
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark05_RDD_Operator_Transform_Test {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - glom
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
        //makeRDD : List => Int
        //glom    : Int  => Array
    
        //需求：先求出每个分区内的最大值，再将各个分区的最大值相加
        //先将各分区内的数据转为数组形式
        val glomRDD: RDD[Array[Int]] = rdd.glom()
    
        //收集各分区的最大值
        val maxRDD: RDD[Int] = glomRDD.map({
          array => {
            array.max
          }
        })
    
        //将各个分区的最大值先收集，再相加
        println(maxRDD.collect().sum)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### groupBy ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    //转换算子 - groupBy : 将数据根据指定的规则进行分组，分区默认不变，但是数据会被打乱重新组合，
    // 我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中。
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark06_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - groupBy
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
    
        //groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
        //相同的key值的数据会放置在一个组中
        def groupFunction(num : Int):Int = {
          num % 2
        }
    
        //这里是将num%2 相同的值进行分组
        val groupRDD: RDD[(Int, Iterable[Int])] = rdd.groupBy(groupFunction)
    
        groupRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### groupBy\_1 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - groupBy : 将数据根据指定的规则进行分组，分区数默认不变，但是数据会被打乱重新组合，
     * 根据key的值进行重新分配，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中。
     * 注意：分组和分区没有本质的联系，分组就是将相同的key的值放入一组，可能所有数据都放入一个组，其他分区空着
     *      一个组的数据放在一个分区中，但并不是说一个分区中的数据只有一个组可以放
     */
    //转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
    object Spark06_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - groupBy
        val rdd: RDD[String] = sc.makeRDD(List("Hello","Scala","Spark","Hadoop"), 2)
    
        //groupBy会将数据源中的每一个数据进行分组判断，根据返回的分组key进行分组
        //相同的key值的数据会放置在一个组中
        //这里是将字符串中首字母相同的字符串放在一起
        val groupRDD: RDD[(Char, Iterable[String])] = rdd.groupBy(_.charAt(0))
    
        groupRDD.collect().foreach(println)
     
        //TODO 关闭
        sc.stop()
      }
    
    }

### filter ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - filter : 将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
     * 当数据进行筛选过滤后，分区不变，但是分区内的数据可能不平衡，生产环境下，可能会出现数据倾斜的情况。
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark07_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - filter
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
    
        //需求：把奇数留下，把偶数过滤掉
    //    val dataRDD: RDD[Int] = rdd.filter(num => num % 2 == 0)
        val dataRDD: RDD[Int] = rdd.filter(_ % 2 != 0)
    
        dataRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### sample ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - sample : 根据指定的规则从数据集中抽取数据
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark08_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - sample
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6,7,8,9,10))
    
        /**
         * sample算子需要传递三个参数
         * 1.第一个参数表示，抽取数据后是否将数据返回 true（返回）、false（丢弃）
         * 2.第二个参数表示，
         *          如果抽取不放回（false）的场合：数据源中每条数据被抽取的概率，基准值的概率
         *          如果抽取放回（true）的场合：表示数据源中的每条数据被抽取的可能次数
         * 3.第三个参数表示，抽取数据时随机算法的种子
         *                如果不传递第三个参数，那么使用的是当前系统时间
         */
    //      println(rdd.sample(
    //        false,
    //        0.4
    //      ).collect().mkString(","))
    
          println(rdd.sample(
            true,
            2
          ).collect().mkString(","))
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

## 宽依赖： ##

### distinct ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - distinct : 将数据集中重复的数据去重
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark09_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - distinct
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,1, 2, 3, 4))
    
        //map(x => (x,null).reduceByKey((x,_) => x, numPartitions).map(_._1))
    
        //(1,null),(2,null),(3,null),(4,null),(1,null),(2,null),(3,null),(4,null)
        //(1,null)(1,null)(1,null)
        //(null,null) => null
        //(1,null) => 1
        //这里的distinct底层不是用的hashset去重，而是分布式的处理，将一条条key-value处理成最终需要的结果
        val rdd1: RDD[Int] = rdd.distinct()
    
        rdd1.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### coalesce ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - coalesce : 根据数据量大小进行缩减分区内的数据，用于大数据集过滤后，提高小数据集的执行效率
     * 当Spark程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本
     * 举例：
     * 2个分区各有1亿条数据，将这两个分区过滤数据成小数据集，每个分区过滤后有10条数据
     * 这样数据集小了，但开启资源调度的成本大了，所以将两个分区合并成一个，只开启一个资源调度器
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark010_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - coalesce
    //    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),4)//开启4个分区
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6),3)//开启3个分区
    
        /**
         * coalesce方法默认情况下不会讲分区的数据打乱重新组合
         * 例如：
         * （1,2,3,4,5,6）在3个分区中，分别为（1,2）、（3,4）、（5,6）
         * coalesce（2）之后，数据为（1,2）、（3,4,5,6）
         * 也就是说分区内的数据不会被打乱，会被整体合并
         * 这种情况下的缩减分区可能会导致数据不均衡，出现数据倾斜
         * 如果想要让数据均衡，可以进行shuffle处理
         * coalesce方法可以传入两个参数：coalesce(合并后最终分区数，是否shuffle)
         */
          //需求，缩减分区
    //    val newRDD: RDD[Int] = rdd.coalesce(2)//默认不开启shuffle，默认为false
        val newRDD: RDD[Int] = rdd.coalesce(2,true)//开启shuffle
    
        //saveAsTextFile:将数据输出到文件夹中
        newRDD.saveAsTextFile("Output")
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### repartition ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - repartition : 扩大分区
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark011_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - repartition
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4,5,6),2)//开启2个分区
    
        /**
         * coalesce算子可以扩大分区，但是如果不进行shuffle操作，是没有意义的，不起作用
         * 因为没有shuffle，分区内的数据不会打乱，所以不能扩大。开启shuffle即传入true
         *
         * spark提供了一个简化的操作：
         * 缩减分区：coalesce，如果想要数据均衡，可以采用shuffle
         * 扩大分区：repartition，底层代码调用的就是coalesce，而且肯定采用shuffle
         * repartition 源码：
         * def repartition(numPartitions: Int)(implicit ord: Ordering[T] = null): RDD[T] = withScope {
         * coalesce(numPartitions, shuffle = true)
         * }
         */
        //需求：扩大分区,将2个分区扩大成3个
    //    val newRDD = rdd.coalesce(3)//没有意义，不会扩大分区
    //    val newRDD: RDD[Int] = rdd.coalesce(3, true)
        val newRDD: RDD[Int] = rdd.repartition(3)
        //saveAsTextFile:将数据输出到文件夹中
        newRDD.saveAsTextFile("Output")
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### sortBy ###

### sortBy\_1 ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - sortBy : 根据指定规则进行排序
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark012_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - sortBy
    
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(("1", 1), ("11", 2), ("2", 3)), 2)
    
        /**
         * sortBy 方法可以根据指定的规则对数据源中的数据进行排序，默认为升序，第二个参数可以改变排序的方式
         * sortBy 默认情况下，不会改变分区，但是中间存在shuffle操作
         */
        //需求：将元组对第一个元素按字典大小进行排序
    //    val newRDD: RDD[(String, Int)] = rdd.sortBy(t => t._1)
        //需求：将元组中第一个元素转为Int类型再进行排序，并且按照降序方式排序
        val newRDD: RDD[(String, Int)] = rdd.sortBy(t => t._1.toInt,false)
    
        newRDD.saveAsTextFile("output")
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### 双value类型：intersection、union、substract、zip ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - 双value类型 : 对源RDD和参数RDD求 交集 / 并集 / 差集 后，返回一个新的RDD
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark013_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - 双value类型
        /**
         * 注意：
         * 交集、并集和差集要求两个数据源数据类型保持一致，否则会报错
         * 拉链操作两个数据源的类型可以不一致。因为不涉及比较，只是把对应位置的元素放一起而已
         */
        val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
        val rdd2: RDD[Int] = sc.makeRDD(List(3, 4, 5, 6))
        val rdd7: RDD[String] = sc.makeRDD(List("3", "4", "5", "6"))
    
        //交集 [3,4]
        val rdd3: RDD[Int] = rdd1.intersection(rdd2)
        println(rdd3.collect().mkString(","))
    
        //并集 [1, 2, 3, 4, 5, 6]
        val rdd4: RDD[Int] = rdd1.union(rdd2)
        println(rdd4.collect().mkString(","))
    
        //差集，站在1的角度，差集就是除去与2共有的数据，剩下的数据
        //差集 [1,2]
        val rdd5: RDD[Int] = rdd1.subtract(rdd2)
        println(rdd5.collect().mkString(","))
    
        //拉链 ： 将两个数据集中相同位置的数据放一起
        //(1,3) (2,4) (3,5) (4,6)
        val rdd6: RDD[(Int, Int)] = rdd1.zip(rdd2)
        val rdd8: RDD[(Int, String)] = rdd1.zip(rdd7)//拉链操作允许两个数据源的数据类型不一致
        println(rdd6.collect().mkString(","))
        println(rdd8.collect().mkString(","))
    
        //TODO 关闭
        sc.stop()
      }
    
    }

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - 双value类型 : 对源RDD和参数RDD求 交集 / 并集 / 差集 后，返回一个新的RDD
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark013_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - 双value类型
        /**
         * Can't zip RDDs with unequal numbers of partitions: List(2, 4)
         * 两个数据源要求分区数量要保持一致
         * Can only zip RDDs with same number of elements in each partition
         * 两个数据源要求分区中的数据量要保持一致
         *
         * 总结：拉链操作必须在两个数据源相同分区数并且相同数据量的情况下才能使用
         */
          //两个数据源的分区数不同，不能进行拉链
    //    val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
    //    val rdd2: RDD[Int] = sc.makeRDD(List(3, 4, 5, 6),4)
    
        //两个数据源的分区中数据量不同，不能进行拉链
    //    val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4, 5, 6),2)
    //    val rdd2: RDD[Int] = sc.makeRDD(List(3, 4, 5, 6),2)
    
        val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
        val rdd2: RDD[Int] = sc.makeRDD(List(3, 4, 5, 6),2)
    
        //拉链 ： 将两个数据集中相同位置的数据放一起
        val rdd3: RDD[(Int, Int)] = rdd1.zip(rdd2)
        println(rdd3.collect().mkString(","))
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### Key-value类型： ###

### partitionBy ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * partitionBy : 将数据按照指定Partitioner重新进行分区，Spark默认的分区器是HashPartitioner
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark014_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
    
        //key-value类型，所以要穿键值对形式的值
        val mapRDD: RDD[(Int, Int)] = rdd.map((_, 1))
    
        //partitionBy根据指定的分区规则对数据进行重分区，注意不是改变分区数
        //这里对数据重分区，是按照hash取模来进行分区的
        //注意：多次调用partitionBy进行重分区，返回的结果是一样的，它底层就是取模计算，所以结果不会改变
        mapRDD.partitionBy(new HashPartitioner(2)).saveAsTextFile("output")
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### reduceByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{HashPartitioner, SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * reduceByKey : 可以将数据按照相同的 Key 对 Value进行聚合
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark015_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("a", 3), ("b", 1)
        ))
    
        //reduceByKey : 可以将数据按照相同的 Key 对 Value进行聚合
        //scala语言中一般的聚合操作都是两两聚合，spark基于scala开发的，所以它的聚合也是两两聚合
        //[1,2,3]
        //[3,3]
        //[6]
        //reduceByKey中如果key的数据只有一个的话，是不会参与运算的。
        //这里的匿名函数中的x 和 y参数，是两个相同key的value值，因为是两两聚合
        val reduceRDD: RDD[(String, Int)] = rdd.reduceByKey((x: Int, y: Int) => {
          x + y
        })
    
        reduceRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### groupByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * groupByKey : 将数据源中的数据，相同key的数据分在一个组中，形成一个对偶元组
     *              元组中的第一个元素就是key
     *              元组中的第二个元素是相同key对应所有value的集合
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark016_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("a", 3), ("b", 1)
        ))
    
        val groupRDD: RDD[(String, Iterable[Int])] = rdd.groupByKey()
        //(a,CompactBuffer(1, 2, 3))
        //(b,CompactBuffer(1))
        groupRDD.collect().foreach(println)
    
        //(a,CompactBuffer((a,1), (a,2), (a,3)))
        //(b,CompactBuffer((b,1)))
        val value = rdd.groupBy(_._1)
        value.collect().foreach(println)
    
        /**
         * groupByKey 和 groupBy的区别：
         * groupByKey不用传参数，会按照元组中的key进行分组，并且返回的是对偶元组
         * (a,CompactBuffer(1, 2, 3))
         * (b,CompactBuffer(1))
         *
         * groupBy需要传入参数，参数为对元组中的哪个元素进行分组，并且返回一个个元组
         * (a,CompactBuffer((a,1), (a,2), (a,3)))
         * (b,CompactBuffer((b,1)))
         */
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### aggregateByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * aggregateByKey : 将数据根据不同的规则进行分区内计算和分区间计算
     * 存在函数柯里化，有两个参数列表：
     * 第一个参数列表，需要传递一个参数，表示为初始值
     *      主要用于当碰见第一个key的时候，可以和value进行分区内计算
     * 第二个参数列表需要传递2个参数
     *      第一个参数表示分区内计算规则
     *      第二个参数表示分区间计算规则
     *注意：reduceByKey分区内和分区间的分组聚合功能是一样的，所以引入了aggregateByKey，可以分别指定分区内和分区间的聚合规则
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark017_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("a", 3), ("a", 4)
        ),2)
    
        //第一个参数列表，需要传递一个参数，表示为初始值
        // *      主要用于当碰见第一个key的时候，可以和value进行分区内计算
        // * 第二个参数列表需要传递2个参数
        // *      第一个参数表示分区内计算规则
        // *      第二个参数表示分区间计算规则
       rdd.aggregateByKey(0)(
         (x,y) => math.max(x,y),
         (x,y) => x+y
       ).collect.foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### foldByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * foldByKey : 如果聚合计算时，分区内和分区间计算规则相同，spark提供了简化的方法
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark017_RDD_Operator_Transform1 {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("b", 3),
          ("b", 4),("b",5),("a",6)
        ),2)
    
    
    //   rdd.aggregateByKey(0)(_+_,_+_).collect.foreach(println)
    
        //foldByKey : 如果聚合计算时，分区内和分区间计算规则相同，spark提供了简化的方法
        rdd.foldByKey(0)(_+_)//等价于上面的aggregateByKey
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### combineByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * combineByKey : 方法需要三个参数
     * 第一个参数表示：将相同key的第一个数据进行结构的转换，实现操作
     * 第二个参数表示：分区内的计算规则
     * 第三个参数表示：分区间的计算规则
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark019_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("b", 3),
          ("b", 4),("b",5),("a",6)
        ),2)
    
        val newRDD: RDD[(String, (Int, Int))] = rdd.combineByKey(
          v => (v, 1),
          (t: (Int, Int), v) => {
            (t._1 + v, t._2 + 1)
          },
          (t1: (Int, Int), t2: (Int, Int)) => {
            (t1._1 + t2._1, t1._2 + t2._2)
          }
        )
    
        val resultRdd: RDD[(String, Int)] = newRDD.mapValues {
          case (num, cnt) => {
            num / cnt
          }
        }
    
        resultRdd.collect().foreach(println)
        //TODO 关闭
        sc.stop()
      }
    
    }

### join ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * join : 在类型为（K,V）和（K,W）的RDD上调整，返回一个相同key对应的所有元素连接在一起的（K，（V,W））的RDD
     *        如果两个数据源中key没有匹配上（只有一放有一个key），那么数据不会出现在结果中
     *        如果两个数据源中key有多个相同的，那么会依次匹配，可能会出现笛卡尔积，造成内存溢出
     *        （所以尽量不要用join,可能会产生笛卡尔积，spark还有leftOuterJoin 和 rightOuterJoin可以使用）
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark21_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("b", 2), ("c", 3)))
    
        val rdd1: RDD[(String, Int)] = sc.makeRDD(List(
          ("c", 7), ("b", 3),  ("a", 4)))
    
        //(a,(1,4))
        //(b,(2,3))
        //(c,(3,7))
        val joinRDD: RDD[(String, (Int, Int))] = rdd.join(rdd1)
    
        joinRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### leftOuterJoin、rightOuterJoin ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * leftOuterJoin : 类似于SQL中的左外连接，返回左表全部数据和右表匹配的数据
     * rightOuterJoin : 类似于SQL中的右外连接，返回右表全部数据和左表匹配的数据
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark22_RDD_Operator_Transform {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO （转换）算子 - Key-Value类型
        val rdd: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("b", 2), ("c", 3)
        ))
    
        val rdd1: RDD[(String, Int)] = sc.makeRDD(List(
          ("c", 7), ("b", 3)//,  ("a", 4)
        ))
    
        //(a,(1,None))
        //(b,(2,Some(3)))
        //(c,(3,Some(7)))
        val leftJoinRDD: RDD[(String, (Int, Option[Int]))] = rdd.leftOuterJoin(rdd1)
    
        leftJoinRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### cogroup ###

package com.atguigu.bigdata.spark.core.rdd.operator.transform
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 转换算子 - Key-Value类型 :
     * cogroup ： 在类型为（K,V）和 （K,W）的RDD上调用，返回一个（K，（Iterable<V>,Iterable<W>））类型的RDD
     * 转换算子：功能的补充和封装，将旧的RDD包装成新的RDD
     */
    object Spark24_RDD_require {
      def main(args: Array[String]): Unit = {
    
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        //TODO 案例实操：展现出各省份各广告的top3
    
        //1.获取原始数据：时间戳、省份、城市、用户、广告
        val dataRDD: RDD[String] = sc.textFile("datas/agent.log")
    
        //2.将原始数据进行结构的转换，方便统计
        //   时间戳、省份、城市、用户、广告 => （（省份，广告），1）
        val mapRDD: RDD[((String, String), Int)] = dataRDD.map({
          line => {
            val datas: Array[String] = line.split(" ")
            ((datas(1), datas(2)), 1)
          }
        })
    
        //3.将转换结构后的数据，进行分组聚合
        //  （（省份，广告），1） => （（省份，广告），sum）
        val reduceRDD: RDD[((String, String), Int)] = mapRDD.reduceByKey(_ + _)
    
        //4.将聚合的结果进行结构的转换
        //  （（省份，广告），sum） => （省份，（广告，sum））
        val newMapRDD = reduceRDD.map {
          case ((pre, ad), sum) => {
            (pre, (ad, sum))
          }
        }
    
        //5.将转换结构后的数据根据省份进行分组
        //  （省份，【（广告A，sumA），（广告B，sumB）】）
        val groupRDD: RDD[(String, Iterable[(String, Int)])] = newMapRDD.groupByKey()
    
        //6.将分组后的数据组内排序（降序），取前3名
        //mapValues ：取的值是map中的Values，不是key
        val resultRDD: RDD[(String, List[(String, Int)])] = groupRDD.mapValues(
          iter => {
            iter.toList.sortBy(_._2)(Ordering.Int.reverse).take(3)
          }
        )
    
        //7.采集数据打印在控制台
        resultRDD.collect().foreach(println)
    
        //TODO 关闭
        sc.stop()
      }
    }

# action： #

行动算子，触发作业（Job）执行的方法，触发任务的调度和作业的执行

### collect ###

package com.atguigu.bigdata.spark.core.rdd.operator.action
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行collect
     */
    object Spark01_RDD_Operator_Action {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
        //TODO 行动算子
        /**
         * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行collect
         * 底层代码调用的是环境对象的runJob方法
         * 底层代码中会创建ActiveJob，并提交执行
         */
        rdd.collect()
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### reduce、count、first、take、takeOrdered ###

package com.atguigu.bigdata.spark.core.rdd.operator.action
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行
     * 转换算子是将旧的RDD包装成新的RDD，返回的结果是一个新的RDD，
     * 而行动算子会触发任务的调度和作业的执行，返回的直接是处理后的结果，而不是新的RDD。
     */
    object Spark02_RDD_Operator_Action {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
        //TODO 行动算子
    
        //reduce : 聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据
        val i: Int = rdd.reduce(_ + _)
        println(i)
    
        //collect : 方法会将不同分区的数据按照分区顺序采集到Driver端内存中，形成数组
        val ints: Array[Int] = rdd.collect()
        println(ints.mkString(","))
    
        //count : 返回数据源中数据的个数
        val cnt: Long = rdd.count()
        println(cnt)
    
        //first : 获取数据源中数据的第一个
        val first: Int = rdd.first()
        println(first)
    
        //take : 获取N个数据
        val ints1: Array[Int] = rdd.take(3)
        println(ints1.mkString(","))
    
        //takeOrdered : 数据先按从小到大排序后，再取前N个数据
        val rdd1: RDD[Int] = sc.makeRDD(List(4, 2, 3, 1))
        val ints3: Array[Int] = rdd1.takeOrdered(3)
        println(ints3.mkString(","))
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### aggregate、fold ###

package com.atguigu.bigdata.spark.core.rdd.operator.action
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行
     * 转换算子是将旧的RDD包装成新的RDD，返回的结果是一个新的RDD，
     * 而行动算子会触发任务的调度和作业的执行，返回的直接是处理后的结果，而不是新的RDD。
     */
    object Spark03_RDD_Operator_Action {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4),2)
        //TODO 行动算子
    
        //aggregateByKey : 初始值只会参与分区内计算
        //（10+3）+（10+7）
        //aggregate : 分区数据与初始值比较，第一个（）传入初始值，第二个括号中，第一个参数填分区内计算规则，第二个参数填分区间计算规则
        //            注意： 初始值会参与分区内计算，并且也会参与分区间计算
        //10+（10+3）+（10+7）
        val result: Int = rdd.aggregate(10)(_ + _, _ + _)
        println(result)
    
        //fold ： 在aggregate中，当分区内和分区间的计算规则相同时，可以使用fold简化，只传一个参数即可
        val i: Int = rdd.fold(10)(_ + _)
        println(i)
    
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### countByValue、countByKey ###

package com.atguigu.bigdata.spark.core.rdd.operator.action
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行
     * 转换算子是将旧的RDD包装成新的RDD，返回的结果是一个新的RDD，
     * 而行动算子会触发任务的调度和作业的执行，返回的直接是处理后的结果，而不是新的RDD。
     */
    object Spark04_RDD_Operator_Action {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 2, 3, 4),2)
        val rdd2: RDD[(String, Int)] = sc.makeRDD(List(
          ("a", 1), ("a", 2), ("a", 3),("b",2)
        ))
        //TODO 行动算子
    
        //countByValue : 统计每个数据出现的频次  Map(4 -> 1, 2 -> 2, 1 -> 1, 3 -> 1)
        val intToLong: collection.Map[Int, Long] = rdd1.countByValue()
        println(intToLong)
    
        //countByKey : 统计每个key出现的频次   Map(a -> 3, b -> 1)
        val stringToLong: collection.Map[String, Long] = rdd2.countByKey()
        println(stringToLong)
    
        //TODO 关闭
        sc.stop()
      }
    
    }

### foreach ###

package com.atguigu.bigdata.spark.core.rdd.operator.action
    
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    
    /**
     * 行动算子 ： 所谓的行动算子，其实就是触发作业（Job）执行的方法，触发任务的调度和作业的执行
     * 转换算子是将旧的RDD包装成新的RDD，返回的结果是一个新的RDD，
     * 而行动算子会触发任务的调度和作业的执行，返回的直接是处理后的结果，而不是新的RDD。
     */
    object Spark05_RDD_Operator_Action {
      def main(args: Array[String]): Unit = {
        //TODO 环境准备
        val sparkConf = new SparkConf().setMaster("local[*]").setAppName("Operator")
        val sc = new SparkContext(sparkConf)
    
        val rdd1: RDD[Int] = sc.makeRDD(List(1, 2, 2, 3, 4),2)
        //TODO 行动算子 foreach
    
        //这里执行的foreach，其实是Driver端内存集合的循环遍历方法，所以数据按顺序打印
        rdd1.collect().foreach(println)
        //这里执行的foreach，其实是Executor端内存数据打印,已经是分布式处理了，所以数据没有按顺序打印
        rdd1.foreach(println)
    
        /**
         * 算子 ： Operator（操作）
         *        RDD的方法和Scala集合对象的方法不一样
         *        集合对象的方法都是在同一个节点的内存中完成的
         *        RDD的方法可以将计算逻辑发送到Executor端（分布式节点）执行
         *        为了区分不同的处理效果，所以将RDD的方法称之为算子
         *        RDD的方法外部的操作都是在Driver端执行的，而方法内部的逻辑代码都是在Executor端执行的。
         */
    
        //TODO 关闭
        sc.stop()
      }
    
    }