package date_20250401

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

object task {
    
    def main(args: Array[String]): Unit = {
        val conf: SparkConf = new SparkConf().setMaster("local") // 启动本地化计算，默认1个CPU核数
        .setAppName("testRdd")
        // 设置本程序名称
        
        // Spark程序的编写都是从SparkContext开始的
        val sc = new SparkContext(conf)
        
        // 1、map算子：现有一个序列Seq(2, 3, 4, 5,6)，请使用map算子，序列每个元素乘以一个数，这个数是你学号最后两位数，然后打印结果。
        println("----1----")
        // val data1: RDD[Int] = sc.parallelize(Seq(2, 3, 4, 5, 6))
        // data1.map(_ * 28).foreach(println)
        
        // 2、flatMap算子：现有一个序列Seq("Hello lily", "Hello lucy", "Hello 你的名字拼音")，请使用flatMap算子，按空格切分单词，输出一个新的序列
        println("----2----")
        val data2: RDD[String] = sc.parallelize(Seq("Hello lily", "Hello lucy", "Hello xulongjin"))
        data2.flatMap(_.split(" ")).foreach(println)
        
        // 3、filter算子：现有一个序列Seq(4, 5,62, 31, 4, 50,6)，请使用filter算子，过滤大于10的元素，输出一个新的序列
        println("----3----")
        val data3: RDD[Int] = sc.parallelize(Seq(4, 5, 62, 31, 4, 50, 6))
        data3.filter(_ > 10).foreach(println)
        
        // 4、mapValues算子：现有一个序列Seq(("a",11), ("b",21), ("c",43))，请使用mapValues算子，每个Value值乘以20，输出一个新的序列
        println("----4----")
        val data4: RDD[(String, Int)] = sc.parallelize(Seq(("a", 11), ("b", 21), ("c", 43)))
        data4.mapValues(_ * 20).foreach(println)
        
        // 5、sample算子：现有一个序列Seq(1,2,3,4,5,6,7,8,9,10)，请使用sample算子进行抽样，抽样参数自定义，输出一个新的序列
        println("----5----")
        val data5: RDD[Int] = sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
        data5.sample(withReplacement = true, 0.7, 3).foreach(println)
        
        // 6、union算子：请自定义两个序列，然后使用union算子，输出一个新的序列
        println("----6----")
        val data6_1: RDD[Int] = sc.parallelize(Seq(1, 2, 3, 4, 5))
        val data6_2: RDD[Int] = sc.parallelize(Seq(6, 7, 8, 9, 10))
        
        val data6_re: RDD[Int] = data6_1.union(data6_2)
        data6_re.foreach(println)
        
        // 7、intersection算子：请自定义两个序列，然后使用intersection算子，求它们的交集，输出一个新的序列
        println("----7----")
        val data7_1: RDD[Int] = sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8))
        val data7_2: RDD[Int] = sc.parallelize(Seq(2, 4, 6, 8, 10))
        data7_1.intersection(data7_2).foreach(println)
        
        
        // 8、distinct算子：请自定义一个序列，然后使用distinct算子，输出一个新的序列
        println("----8----")
        val data8: RDD[Int] = sc.parallelize(Seq(1, 2, 3, 4, 5, 6, 7, 8, 2, 4, 6, 8, 10))
        data8.distinct().foreach(println)
        
        // 9、reduceByKey算子：现有一个序列Seq(("a",1), ("b",1), ("c",1), ("a",1), ("d",1), ("c",1))，然后使用reduceByKey算子，输出一个新的序列
        println("----9----")
        val data9: RDD[(String, Int)] = sc.parallelize(Seq(("a", 1), ("b", 1), ("c", 1), ("a", 1), ("d", 1), ("c", 1)))
        data9.reduceByKey(_ + _).foreach(println)
        
        // 10、groupByKey算子：现有一个序列Seq(("a",1), ("b",1), ("c",1), ("a",1), ("d",1), ("c",1))，然后使用groupByKey算子，输出一个新的序列
        println("----10----")
        val data10: RDD[(String, Int)] = sc.parallelize(Seq(("a", 1), ("b", 1), ("c", 1), ("a", 1), ("d", 1), ("c", 1)))
        data10.groupByKey().foreach(println)
        
        // 11、join算子：请自定义两个map结构的序列，然后使用join算子，输出一个新的序列
        println("----11----")
        val data11_1: RDD[(String, Int)] = sc.parallelize(Seq(("a", 1), ("a", 2), ("b", 1)))
        val data11_2: RDD[(String, Int)] = sc.parallelize(Seq(("a", 10), ("a", 11), ("a", 12)))
        data11_1.join(data11_2).foreach(println)
        
        // 12、sortBy算子：现有一个序列Seq(("e", 4),("a", 3), ("b", 2), ("c", 1), ("d", 5))，然后使用sortBy算子，分别按照key值和value值排序，输出一个新的序列
        println("----12----")
        val data12: RDD[(String, Int)] = sc.parallelize(Seq(("e", 4), ("a", 3), ("b", 2), ("c", 1), ("d", 5)))
        data12.sortBy(_._1).foreach(println)
        println("----------")
        data12.sortBy(_._2, false).foreach(println)
        
    }
    
}
