Spark初级编程实践

Meguling

已于 2025-06-29 15:49:31 修改

阅读量495

点赞数 8

CC 4.0 BY-SA版权

文章标签： spark 大数据分布式 sql java

于 2025-06-29 15:46:07 首次发布

本文链接：https://blog.youkuaiyun.com/Meguling/article/details/148998415

Spark RDD行动算子介绍

在Apache Spark中，RDD（Resilient Distributed Dataset，弹性分布式数据集）是核心的数据抽象。RDD操作分为两类：转换算子（Transformations） 和 行动算子（Actions）。行动算子是触发实际计算的操作，它们会强制Spark执行之前定义的转换操作链，并将结果返回给驱动程序或写入外部存储系统。

Spark编程基础

一、创建RDD

1、从集合（内存）中创建 RDD

从集合中创建RDD， Spark主要提供了两个方法：parallelize和makeRDD

// 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过内存创建RDD
     val rdd1 = sc.parallelize(List(1, 2, 3, 4))
     val rdd2 = sc.makeRDD(List(1, 2, 3, 4))
     
     rdd1.collect().foreach(println)
     rdd2.collect().foreach(println)2）从外部存储（文件）创建 RDD
由外部存储系统的数据集创建RDD包括：本地的文件系统，所有Hadoop支持的数据集
比如HDFS、HBase等。
// 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     var rdd3: RDD[String] = sc.textFile("input")
     rdd3.collect().foreach(println)
     sc.stop()

2、从其他 RDD 创建

主要是通过一个RDD 运算完后，再产生新的 RDD

3、直接创建 RDD new

使用new 的方式直接构造 RDD

二、RDD 并行度与分区

Spark可以将一个作业切分多个任务后，发送给Executor节点并行计算，而能够并行计算的任务数量我们称之为并行度。-- 并行执行的任务数量，并不是指的切分任务的数量

// 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     var rdd3: RDD[String] = sc.textFile("input",4)
     rdd3.collect().foreach(println)
     sc.stop()

读取内存数据时，数据可以按照并行度的设定进行数据的分区操作；读取文件数据时，数据是按照Hadoop文件读取的规则进行切片分区，而切片规则和数据读取的规则有些差异。

三、RDD 转换算子

RDD根据数据处理方式的不同将算子整体上分为Value类型、双Value类型和Key-Value类型

Value类型

1）map 
将处理的数据逐条进行映射转换，这里的转换可以是类型的转换，也可以是值的转换。
    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
     val doubleRDD: RDD[Int] = sourceRDD.map(line => line * 2)
     val StringRDD: RDD[String] = sourceRDD.map(line => line.toString)
     doubleRDD.collect().foreach(println)
     StringRDD.collect().foreach(println)
     sc.stop()2) map Partitions
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据。
    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
     val doubleRDD: RDD[Int] = sourceRDD.mapPartitions(datas => datas.filter(_>=2))
     doubleRDD.collect().foreach(println)
     sc.stop()

map和mapPartitions的区别

从数据处理角度：Map算子是分区内一个数据一个数据的执行，类似于串行操作。而mapPartitions算子是以分区为单位进行批处理操作。
从功能的角度：Map算子主要目的将数据源中的数据进行转换和改变。但是不会减少或增多数据。MapPartitions算子需要传递一个迭代器，返回一个迭代器，没有要求的元素的个数保持不变，所以可以增加或减少数据。
从性能的角度：Map算子因为类似于串行操作，所以性能比较低，而是mapPartitions算子类似于批处理，所以性能较高。但是mapPartitions算子会长时间占用内存，那么这样会导致内存可能不够用，出现内存溢出的错误。所以在内存有限的情况下，不推荐使用。

3) mapPartitionsWithIndex
将待处理的数据以分区为单位发送到计算节点进行处理，这里的处理是指可以进行任意的处理，哪怕是过滤数据，在处理时同时可以获取当前分区索引。
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
  
     val mapPartitionRDD: RDD[(Int, Int)] = sourceRDD.mapPartitionsWithIndex(
       (index, datas) => {
         datas.map(line => (index, line)).filter(_._1>5)
       }
     )
     mapPartitionRDD.collect().foreach(println)
     sc.stop()4) flatMap
将处理的数据进行扁平化后再进行映射处理，所以算子也称之为扁平映射
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD= sc.makeRDD(List(List(1,2),List(3,4)),1)
     val flatmapRDD = sourceRDD.flatMap(list => list)
     flatmapRDD.collect().foreach(println)
     sc.stop()>将List(List(1,2),3,List(4,5))进行扁平化操作
val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD= sc.makeRDD(List(List(1,2),3,List(4,5)),1)
     val flatmapRDD = sourceRDD.flatMap(list =>
       list match {
         case list:List[_] => list
         case dat => List(dat)
       }
     )
     flatmapRDD.collect().foreach(println)
     sc.stop()5) glom
将同一个分区的数据直接转换为相同类型的内存数组进行处理，分区不变
    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD= sc.makeRDD(List(1,2,3,4,5),1)
     val glomRDD: RDD[Array[Int]] = sourceRDD.glom()
     glomRDD.collect().foreach(data=>println(data.mkString(",")))
     sc.stop()6) groupBy
将数据根据指定的规则进行分组, 分区默认不变，但是数据会被打乱重新组合，我们将这样的操作称之为shuffle。极限情况下，数据可能被分在同一个分区中
    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD= sc.makeRDD(List("Hello", "hive", "hbase", "Hadoop"))
     val mapRDD: RDD[(String, String)] = sourceRDD.map(line => (line.take(1), line))
     val groupRDD: RDD[(String, Iterable[(String, String)])] = mapRDD.groupBy(_._1)
     groupRDD.collect().foreach(println)
     sc.stop()7) filter
将数据根据指定的规则进行筛选过滤，符合规则的数据保留，不符合规则的数据丢弃。
 当数据进行筛选过滤后，分区不变，但是分区内的数据可能不均衡，生产环境下，可能会出现数据倾斜。    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val sourceRDD= sc.makeRDD(List(1,2,3,4),1)
     val filterRDD = sourceRDD.filter(_%2 == 0)
     filterRDD.collect().foreach(println)
     sc.stop()8) sample
根据指定的规则从数据集中抽取数据
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val dataRDD = sc.makeRDD(List(
       1,2,3,4
     ))
       // 抽取数据不放回（伯努利算法）
       // 伯努利算法：又叫 0 、 1 分布。例如扔硬币，要么正面，要么反面。
       // 具体实现：根据种子和随机算法算出一个数和第二个参数设置几率比较，小于第二个参数要，大于不要
     // 第一个参数：抽取的数据是否放回， false ：不放回
     // 第二个参数：抽取的几率，范围在 [ 之间 ,0 ：全不取 1 ：全取
     // 第三个参数：随机数种子
     val dataRDD1 = dataRDD.sample(false, 0.5)
     // 抽取数据放回（泊松算法）
     // 第一个参数：抽取的数据是否放回， true ：放回 false ：不放回
     // 第二个参数：重复数据的几率，范围大于等于 0. 表示每一个元素被期望抽取到的次数
     // 第三个参数：随机数种子
     val dataRDD2 = dataRDD.sample(true, 2)
     dataRDD1.collect().foreach(println)
     dataRDD2.collect().foreach(println)
     sc.stop()9) distinct
将数据集中重复的数据去重
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val dataRDD = sc.makeRDD(List(
       1,2,3,4,1,2,3,3,3
     ))
  
     val dataRDD1 = dataRDD.distinct()
     val dataRDD2 = dataRDD.distinct()
  
     dataRDD1.collect().foreach(println)
     dataRDD2.collect().foreach(println)
     sc.stop()10) coalesce
根据数据量缩减分区，用于大数据集过滤后，提高小数据集的执行效率
 当spark程序中，存在过多的小任务的时候，可以通过coalesce方法，收缩合并分区，减少分区的个数，减小任务调度成本val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val dataRDD = sc.makeRDD(List(
       1,2,3,4,1,2,3,3,3
     ),6)
     val dataRDD1 = dataRDD.coalesce(2).glom
     dataRDD1.collect().foreach(data=>println(data.mkString(",")))11) repartition
 该操作内部其实执行的是coalesce操作，参数shuffle的默认值为true。无论是将分区数多的RDD转换为分区数少的RDD，还是将分区数少的RDD转换为分区数多的RDD，repartition操作都可以完成，因为无论如何都会经shuffle过程。
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val dataRDD = sc.makeRDD(List(
       1,2,3,4,1,2,3,3,3
     ),6)
     val dataRDD1 = dataRDD.repartition(3).glom()
     dataRDD1.collect().foreach(data=>println(data.mkString(",")))
     sc.stop()12) sortBy
该操作用于排序数据。在排序之前，可以将数据通过f函数进行处理，之后按照f函数处理的结果进行排序，默认为升序排列。排序后新产生的RDD的分区数与原RDD的分区数一致。中间存在shuffle的过程
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("TranstionRDD01")
     val sc: SparkContext = new SparkContext(sparkConf)
     val dataRDD = sc.makeRDD(List(
       1,2,3,4,1,2,3,3,3
     ),6)
     val dataRDD1 = dataRDD.sortBy(num=>num,true,5).glom()
     dataRDD1.collect().foreach(data=>println(data.mkString(",")))
     sc.stop()双Value类型
13) intersection
对源RDD和参数RDD求交集后返回一个新的RDD
 
    // 创建 Spark 运行配置对象
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
    // 创建 Spark 上下文环境对象（连接对象）
    val sc = new SparkContext(sparkConf)
    //通过外部文件创建RDD
    val dataRDD1 = sc.makeRDD(List(1,2,3,4))
    val dataRDD2 = sc.makeRDD(List(3,4,5,6))
    val dataRDD = dataRDD1.intersection(dataRDD2)
    dataRDD.collect().foreach(println)
    sc.stop()
 
14) union
对源RDD和参数RDD求并集后返回一个新的RDD
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(1,2,3,4))
     val dataRDD2 = sc.makeRDD(List(3,4,5,6))
     val dataRDD = dataRDD1.union(dataRDD2)
     dataRDD.collect().foreach(println)
     sc.stop()15) subtract
以一个RDD元素为主，去除两个RDD中重复元素，将其他元素保留下来。求差集
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(1,2,3,4))
     val dataRDD2 = sc.makeRDD(List(3,4,5,6))
     val dataRDD = dataRDD1.subtract(dataRDD2)
     dataRDD.collect().foreach(println)
     sc.stop()16) zip
将两个RDD中的元素，以键值对的形式进行合并。其中，键值对中的Key为第1个RDD中的元素，Value为第2个RDD中的相同位置的元素。
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(1,2,3,4))
     val dataRDD2 = sc.makeRDD(List(3,4,5,6))
     val dataRDD = dataRDD1.zip(dataRDD2)
     dataRDD.collect().foreach(println)
     sc.stop()Key - Value类型
17) partitionBy
将数据按照指定Partitioner重新进行分区。Spark默认的分区器是HashPartitioner
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[(Int, String)] =
       sc.makeRDD(Array((1,"aaa"),(2,"bbb"),(3,"ccc")),3)
     import org.apache.spark.HashPartitioner
     val rdd2: RDD[(Int, String)] = rdd.partitionBy(new HashPartitioner(2))
     rdd2.collect().foreach(println)
     sc.stop()18) reduceByKey
可以将数据按照相同的Key对Value进行聚合
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",1)))
     val dataRDD2 = dataRDD1.reduceByKey(_+_)
     val dataRDD3 = dataRDD1.reduceByKey(_+_, 2)
     dataRDD2.collect().foreach(println)
     sc.stop()19) groupByKey
将数据源的数据根据key对value进行分组
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",1)))
     val dataRDD2 = dataRDD1. groupByKey
     val dataRDD3 = dataRDD1. groupByKey(2)
     val dataRDD4 = dataRDD1. groupByKey(new HashPartitioner(2))
     dataRDD3.collect().foreach(println)
     sc.stop()

从shuffle的角度：reduceByKey和groupByKey都存在shuffle的操作，但是reduceByKey可以在shuffle前对分区内相同key的数据进行预聚合（combine）功能，这样会减少落盘的数据量，而groupByKey只是进行分组，不存在数据量减少的问题，reduceByKey性能比较高

从功能的角度：reduceByKey其实包含分组和聚合的功能。GroupByKey只能分组，不能聚合，所以在分组聚合的场合下，推荐使用reduceByKey，如果仅仅是分组而不需要聚合。那么还是只能使用groupByKey

将数据根据不同的规则进行分区内计算和分区间计算

// 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",1)))
     val dataRDD2 = dataRDD1. aggregateByKey(0)(_+_ ,_+_)
     dataRDD2.collect().foreach(println)
     sc.stop()21) foldByKey
当分区内计算规则和分区间计算规则相同时，aggregateByKey就可以简化为foldByKey
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("a",1),("a",1)))
     val dataRDD2 = dataRDD1. foldByKey(0)(_+_)
     dataRDD2.collect().foreach(println)
     sc.stop()22) combineByKey
最通用的对key-value型rdd进行聚集操作的聚集函数（aggregation function）。类似于aggregate()，combineByKey()允许用户返回值的类型与输入不一致。
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val list: List[(String, Int)] = List(("a", 88), ("b", 95), ("a", 91), ("b", 93),
       ("a", 95), ("b",98))
     val input: RDD[(String, Int)] = sc.makeRDD(list, 2)
  
     val combineRdd: RDD[(String, (Int, Int))] = input.combineByKey(
     (_,1),
       (acc: (Int, Int), v) => (acc._1 + v, acc._2 + 1),
         (acc1: (Int, Int), acc2: (Int, Int)) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
     )
     combineRdd.collect().foreach(println)
     sc.stop()reduceByKey、foldByKey、aggregateByKey、combineByKey的区别？
 reduceByKey: 相同key的第一个数据不进行任何计算，分区内和分区间计算规则相同
 FoldByKey: 相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则相同
 AggregateByKey：相同key的第一个数据和初始值进行分区内计算，分区内和分区间计算规则可以不相同
 CombineByKey:当计算时，发现数据结构不满足要求时，可以让第一个数据转换结构。分区内和分区间计算规则不相同。23) sortByKey
在一个(K,V)的RDD上调用，K必须实现Ordered接口(特质)，返回一个按照key进行排序的
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
     val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(true)
 //    val sortRDD1: RDD[(String, Int)] = dataRDD1.sortByKey(false)
     sortRDD1.collect().foreach(println)
     sc.stop()24) join
在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素连接在一起的
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[(Int, String)] = sc.makeRDD(Array((1, "a"), (2, "b"), (3, "c")))
     val rdd1: RDD[(Int, Int)] = sc.makeRDD(Array((1, 4), (2, 5), (3, 6)))
     rdd.join(rdd1).collect().foreach(println)
     sc.stop()25) leftOuterJoin
类似于SQL语句的左外连接
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("b",2),("c",3),("d",4)))
     val dataRDD2 = sc.makeRDD(List(("a",1),("b",2),("c",3)))
     val rdd: RDD[(String, (Int, Option[Int]))] = dataRDD1.leftOuterJoin(dataRDD2)
     rdd.collect().foreach(println)
     sc.stop()26) cogroup
在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable<V>,Iterable<W>))类型的RDD
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val dataRDD1 = sc.makeRDD(List(("a",1),("a",2),("b",4)))
     val dataRDD2 = sc.makeRDD(List(("a",1),("c",2),("c",3)))
     val value: RDD[( String, (Iterable[Int], Iterable[Int]))] =
       dataRDD1.cogroup(dataRDD2)
     value.collect().foreach(println)
     sc.stop()4、RDD 行动算子
1) reduce
聚集RDD中的所有元素，先聚合分区内数据，再聚合分区间数据
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     // 聚合数据
     val reduceResult: Int = rdd.reduce(_+_)
     println(reduceResult)
     sc.stop()2) collect
在驱动程序中，以数组Array的形式返回数据集的所有元素
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     // 收集数据到 Driv er
     rdd.collect().foreach(println)
     sc.stop()3) count
返回RDD中元素的个数
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     // 收集数据到 Driv er
     val countResult: Long = rdd.count()
     println(countResult)
     sc.stop()4) first
返回RDD中的第一个元素
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     val firstResult: Int = rdd.first()
     println(firstResult)
     sc.stop()5) take
返回一个由RDD的前n个元素组成的数组
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     val takeResult: Array[Int] = rdd.take(2)
     println(takeResult.mkString(","))
     sc.stop()6) takeOrdered
返回该RDD排序后的前n个元素组成的数组
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,3,2,4))
     // 返回 RDD 中元素的个数
     val result: Array[Int] = rdd.takeOrdered(2)
     println(result.mkString(","))
     sc.stop()7) aggregate
分区的数据通过初始值和分区内的数据进行聚合，然后再和初始值进行分区间的数据聚合
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 8)
     // 将该 RDD 所有元素相加得到结果
     //val result: Int = rdd.aggregate(0)(_ + _, _ +_)
     val result: Int = rdd.aggregate(10)(_ + _, _ + _)
     println(result)
     sc.stop()8) fold
折叠操作，aggregate的简化版操作
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))
     val foldResult: Int = rdd.fold(0)(_+_)
     println(foldResult)
     sc.stop()9) countByKey
统计每种key的个数
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[(Int, String)] = sc.makeRDD(List((1, "a"), (1, "a"), (1, "a"), (2,
       "b"), (3, "c"), (3, "b")))
     // 统计每种 key 的个数
     val result: collection.Map[Int, Long] = rdd.countByKey()
     println(result.mkString(","))
     sc.stop()10) save 相关算子
 函数签名
 def saveAsTextFile(path: String): Unit
 def saveAsObjectFile(path: String): Unit
 def saveAsSequenceFile(
 path: String,
 codec: Option[Class[_ <: CompressionCodec]] = None): Unit
 函数说明
 将数据保存到不同格式的文件中// 保存成 Text 文件
 rdd.saveAsTextFile("output")
 // 序列化成对象保存到文件
 rdd. saveAsObjectFile("output1")
 // 保存成 Sequencefile 文件
 rdd.map((_,1)).saveAsSequenceFile("output2")11) foreach
分布式遍历RDD中的每一个元素，调用指定函数
    // 创建 Spark 运行配置对象
     val sparkConf = new SparkConf().setMaster("local[*]").setAppName("CreateRDD01")
     // 创建 Spark 上下文环境对象（连接对象）
     val sc = new SparkContext(sparkConf)
     //通过外部文件创建RDD
     val rdd: RDD[Int] = sc.makeRDD(List(1,2,3,4))
     // 收集后打印
     rdd.map(num=>num).collect().foreach(println)
     println("****************")
     // 分布式打印
     rdd.foreach(println)
     sc.stop()

Spark SQL

什么是Spark SQL

Spark SQL 是 Apache Spark 生态系统中的核心模块，专为结构化数据处理设计。它将关系型数据库的 SQL 查询能力与 Spark 强大的分布式计算引擎结合，提供高效、易用的大数据分析解决方案。

Spark Core 中，如果想要执行应用程序，需要首先构建上下文环境对象 SparkContext，Spark SQL 其实可以理解为对 Spark Core 的一种封装，不仅仅在模型上进行了封装，上下文环境对象也进行了封装。

在老的版本中，SparkSQL 提供两种 SQL 查询起始点：一个叫SQLContext，用于 Spark自己提供的 SQL 查询；一个叫HiveContext，用于连接 Hive 的查询。

SparkSession 是 Spark 最新的 SQL 查询起始点，实质上是 SQLContext 和 HiveContext的组合，所以在 SQLContex 和 HiveContext 上可用的 API 在 SparkSession 上同样是可以使用的。SparkSession 内部封装了 SparkContext，所以计算实际上是由 sparkContext 完成的。当我们使用 spark-shell 的时候, spark 框架会自动的创建一个名称叫做 spark 的 SparkSession 对象, 就像我们以前可以自动获取到一个 sc 来表示 SparkContext 对象一样。

DataFrame

创建 DataFrame

在 Spark SQL 中 SparkSession 是创建 DataFrame 和执行 SQL 的入口，创建 DataFrame有三种方式：通过 Spark 的数据源进行创建；从一个存在的 RDD 进行转换；还可以从 Hive Table 进行查询返回。

Spark SQL 的 DataFrame API 允许我们使用 DataFrame 而不用必须去注册临时表或者生成 SQL 表达式。DataFrame API 既有 transformation 操作也有 action 操作。

创建 DataFrame
在 Spark SQL 中 SparkSession 是创建 DataFrame 和执行 SQL 的入口，创建 DataFrame有三种方式：通过 Spark 的数据源进行创建；从一个存在的 RDD 进行转换；还可以从 Hive Table 进行查询返回。

从 Spark 数据源进行创建

查看 Spark 支持创建文件的数据源格式
scala> spark.read.
 csv  format  jdbc  json  load  option  options  orc  parquet  schema 
 table  text  textFile
在 spark 的 bin/data 目录中创建 user.json 文件{"username":"zhangsan","age":20}
读取 json 文件创建 DataFramescala> val df = spark.read.json("data/user.json")
 df: org.apache.spark.sql.DataFrame = [age: bigint， username: string] 注意：如果从内存中获取数据，spark 可以知道数据类型具体是什么。如果是数字，默认作为 Int 处理；但是从文件中读取的数字，不能确定是什么类型，所以用 bigint 接收，可以和Long 类型转换，但是和 Int 不能进行转换
展示结果
1. +---+--------+
2. |age|username|
3. +---+--------+
4. | 20|zhangsan|
5. +---+--------
2) 从 RDD 进行转换
在后续章节中讨论
3) 从 Hive Table 进行查询返回
在后续章节中讨论
2.2 SQL 语法
 SQL 语法风格是指我们查询数据的时候使用 SQL 语句来查询，这种风格的查询必须要有临时视图或者全局视图来辅助
1) 读取 JSON 文件创建 DataFrame
 scala> val df = spark.read.json("data/user.json")
 df: org.apache.spark.sql.DataFrame = [age: bigint， username: string] 2) 对 DataFrame 创建一个临时表
 scala> df.createOrReplaceTempView("people")
 3) 通过 SQL 语句实现查询全表
 scala> val sqlDF = spark.sql("SELECT * FROM people")
 sqlDF: org.apache.spark.sql.DataFrame = [age: bigint， name: string] 4) 结果展示
 scala> sqlDF.show
 +---+--------+
 |age|username|
 +---+--------+
 | 20|zhangsan|
 | 30| lisi|
 | 40| wangwu|
 +---+--------+ 注意：普通临时表是 Session 范围内的，如果想应用范围内有效，可以使用全局临时表。使用全局临时表时需要全路径访问，如：global_temp.people
5) 对于 DataFrame 创建一个全局表
 scala> df.createGlobalTempView("people")
 6) 通过 SQL 语句实现查询全表
 2.3 DSL 语法
 DataFrame 提供一个特定领域语言(domain-specific language, DSL)去管理结构化的数据。可以在 Scala, Java, Python 和 R 中使用 DSL，使用 DSL 语法风格不必去创建临时视图了
1) 创建一个 DataFrame
 scala> val df = spark.read.json("data/user.json")
 df: org.apache.spark.sql.DataFrame = [age: bigint， name: string] 2) 查看 DataFrame 的 Schema 信息
 scala> df.printSchema
 root
 |-- age: Long (nullable = true)
 |-- username: string (nullable = true) 3) 只查看"username"列数据，
 scala> df.select("username").show()
 +--------+
 |username|
 +--------+
 |zhangsan|
 | lisi|
 | wangwu|
 +--------+ 4) 查看"username"列数据以及"age+1"数据
 注意:涉及到运算的时候, 每列都必须使用$, 或者采用引号表达式：单引号+字段名
scala> df.select($"username",$"age" + 1).show
 scala> df.select('username, 'age + 1).show()
 scala> df.select('username, 'age + 1 as "newage").show()
 +--------+---------+
 |username|(age + 1)|
 +--------+---------+
 |zhangsan| 21|
 | lisi| 31|
 | wangwu| 41|
 +--------+---------+
查看"age"大于"30"的数据scala> df.filter($"age">30).show
 +---+---------+
 |age| username|
 +---+---------+
 | 40| wangwu|
 +---+---------+
按照"age"分组，查看数据条数scala> df.groupBy("age").count.show
 +---+-----+
 |age|count|
 +---+-----+
 | 20| 1|
 | 30| 1|
 | 40| 1|
 +---+-----+ 2.4 RDD 转换为 DataFrame
 在 IDEA 中开发程序时，如果需要 RDD 与 DF 或者 DS 之间互相操作，那么需要引入
import spark.implicits._
这里的 spark 不是 Scala 中的包名，而是创建的 sparkSession 对象的变量名称，所以必须先创建 SparkSession 对象再导入。这里的 spark 对象不能使用 var 声明，因为 Scala 只支持val 修饰的对象的引入。
spark-shell 中无需导入，自动完成此操作。
scala> val idRDD = sc.textFile("data/id.txt")
 scala> idRDD.toDF("id").show
 +---+
 | id|
 +---+
 | 1|
 | 2|
 | 3|
 | 4|
 +---+ 实际开发中，一般通过样例类将 RDD 转换为 DataFrame
scala> case class User(name:String, age:Int)
 defined class User
 scala> sc.makeRDD(List(("zhangsan",30), ("lisi",40))).map(t=>User(t._1, 
 t._2)).toDF.show
 +--------+---+
 | name|age|
 +--------+---+
 |zhangsan| 30|
 | lisi| 40|
 +--------+---+ 2.5 DataFrame 转换为 RDD
 DataFrame 其实就是对 RDD 的封装，所以可以直接获取内部的 RDD
scala> val df = sc.makeRDD(List(("zhangsan",30), ("lisi",40))).map(t=>User(t._1, t._2)).toDF
 df: org.apache.spark.sql.DataFrame = [name: string, age: int]
  
 scala> val rdd = df.rdd
 rdd: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] = MapPartitionsRDD[46] 
 at rdd at <console>:25
  
 scala> val array = rdd.collect
 array: Array[org.apache.spark.sql.Row] = Array([zhangsan,30], [lisi,40])
 注意：此时得到的 RDD 存储类型为 Rowscala> array(0)
 res28: org.apache.spark.sql.Row = [zhangsan,30]
 scala> array(0)(0)
 res29: Any = zhangsan
 scala> array(0).getAs[String]("name")
 res30: String = zhangsan