SparkCore-RDD编程操作03

最新推荐文章于 2023-05-16 00:42:43 发布
最新推荐文章于 2023-05-16 00:42:43 发布
阅读量143 收藏
点赞数
分类专栏： # spark 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39331255/article/details/111409868
版权

1. Spark程序执行过程

1.1. WordCount案例程序的执行过程

在这里插入图片描述

1.2. Spark程序执行流程

在这里插入图片描述

2. RDD的操作

2.1. RDD的初始化

​ RDD的初始化，原生api提供的2中创建方式，一种就是读取文件textFile，还有一种就是加载一个scala集合parallelize。当然，也可以通过transformation算子来创建的RDD。

2.2. RDD的操作

需要知道RDD操作算子的分类，基本上分为两类：transformation和action，当然更加细致的分，可以分为输入算子，转换算子，缓存算子，行动算子。

在这里插入图片描述

输入：在Spark程序运行中，数据从外部数据空间（如分布式存储：textFile读取HDFS等，parallelize方法输入Scala集合或数据）输入Spark，数据进入Spark运行时数据空间，转化为Spark中的数据块，通过BlockManager进行管理。

运行：在Spark数据输入形成RDD后便可以通过变换算子，如filter等，对数据进行操作并将RDD转化为新的RDD，通过Action算子，触发Spark提交作业。

缓存：如果数据需要复用，可以通过Cache算子，将数据缓存到内存。

输出：程序运行结束数据会输出Spark运行时空间，存储到分布式存储中（如saveAsTextFile输出到HDFS），或Scala数据或集合中（collect输出到Scala集合，count返回Scala int型数据）。

SparkCore编程

 val conf = new SparkConf()
      .setAppName("Demo2")//类名
      .setMaster("local[*]")//指定线程数
    val sc = new SparkContext(conf)
    sc加载数据生成rdd
    rdd使用算子
    sc.stop()

2.3. transformation转换算子详细案例大全

2.4. action行动算子使用案例大全

2.5. 持久化操作

2.6. 共享变量（广播变量/累加器）

3. 高级排序

3.1. 普通的排序

object Demo1 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("_01SparkSortOps")
      .setMaster("local[2]")//在此处和parallelize处都能设置数据分区，此处设置作用于全局
    val sc = new SparkContext(conf)

    val stus:RDD[Student] = sc.parallelize(List(
      Student("卫超", 19, 187),
      Student("王礼鹏", 29, 177),
      Student("乌欣欣", 18, 168),
      Student("陈延年", 19, 157),
      Student("刘龙沛", 20, 175)
    ))
    //都按降序
    //sortbykey(stus)
    //sortby(stus)
    takeOrdered(stus)
  }

  /*排序的算子主要有：
  *    transformation:
    *          sortByKey
      *              按照key进行排序，默认升序，对应的数据类型是K-V
  *              ascending         升序(true)或者降序(false)
  *              numPartitions     排序之后的分区个数
  *          sortBy
    *              可以不用有key来进行排序，但是需要指定进行排序的字段，底层其实就是
  *              map(data => (K, data)).sortBykey()
  *          区别就是groupByKey和groupBy，二者的排序操作，默认是分区内局部有序，全局不一定，如果要做到全局有序，那么partition个数就设置为1，
  *          但是此时的计算性能非常差
    *    action:
    *      takeOrdered: 在拉取数据集的同时，对数据进行排序，如果一些操作，需要进行排序，并返回结果值，此时可以使用takeOrdered而不是先sortBy在take
  *
  */
  //sortbykey
  def sortbykey(stus:RDD[Student]): Unit ={
    stus.map(stu=>(stu.height,stu)).sortByKey(false,1).mapPartitionsWithIndex((index,partition)=>{
      val list = partition.toList
      println(s"分区：${index}的数据为：${list.mkString(",")}")
      list.toIterator
    }).count()
  }
  //sortby
  def sortby(stus:RDD[Student]): Unit ={
    stus.sortBy(stu=>stu.height,false,1).mapPartitionsWithIndex((index,partition)=>{
      val list = partition.toList
      println(s"分区：${index}的数据为：${list.mkString(",")}")
      list.toIterator
    }).count()
  }
  //takeOrdered
  def takeOrdered(stus:RDD[Student]): Unit ={
    val students = stus.takeOrdered(3)(new Ordering[Student]() {
      override def compare(x: Student, y: Student): Int = {
        y.height.compareTo(x.height)
      }
    })
    students.foreach(println)
  }
}
case class Student(name:String,age:Int,height:Int)

3.2. 二次排序

/**
 * @author ljh
 * @create 2020-12-09 11:26
 *二次排序
 */
object Demo2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("_01SparkSortOps")
      .setMaster("local[2]") //在此处和parallelize处都能设置数据分区，此处设置作用于全局
    val sc = new SparkContext(conf)

    val stus: RDD[Student] = sc.parallelize(List(
      Student("卫超", 19, 187),
      Student("王礼鹏", 29, 177),
      Student("乌欣欣", 18, 168),
      Student("陈延年", 19, 157),
      Student("刘龙沛", 20, 177)
    ))
    //sortbykey(stus)
    //sortby(stus)
    takeOrdered(stus)
  }
  //takeOrdered不用改，就可以二次排序
  def takeOrdered(stus:RDD[Student]): Unit ={
    val students = stus.takeOrdered(3)(new Ordering[Student]() {
      override def compare(x: Student, y: Student): Int = {
        var i = x.height.compareTo(y.height)
        if (i == 0) {
          i = y.age.compareTo(x.age)
        }
        i
      }
    })
    students.foreach(println)
  }
  //按照身高升序，如果身高相同，按照年龄进行升序
  def sortbykey(stus:RDD[Student]): Unit ={
    val value = stus.map(stu => (HeightAgeKey(stu.height, stu.age), stu)).sortByKey(numPartitions = 1)
    value.foreach(println)
  }
  //按照身高升序，如果身高相同，按照年龄进行降序
  def sortby(stus:RDD[Student]): Unit = {
    stus.sortBy(stu => stu, numPartitions = 1)(new Ordering[Student] {
      override def compare(x: Student, y: Student): Int = {
        var i = x.height.compareTo(y.height)
        if (i == 0) {
          i = y.age.compareTo(x.age)
        }
        i
      }
    },ClassTag.Object.asInstanceOf[ClassTag[Student]]//运行时的泛型对象
    ).foreach(println)

  }
}

case class HeightAgeKey(height:Int,age:Int) extends Ordered[HeightAgeKey] {
  override def compare(that: HeightAgeKey): Int = {
    var i = height.compareTo(that.height)
    if(i==0){
      i=age.compareTo(that.age)
    }
    i
  }
}

3.3. 分组排序

object Demo3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Demo3")
      .setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(List(
      "chinese ls 91",
      "english ww 56",
      "chinese zs 90",
      "chinese zl 76",
      "english zq 88",
      "chinese wb 95",
      "chinese sj 74",
      "english ts 87",
      "english ys 67",
      "english mz 77",
      "chinese yj 98",
      "english gk 96"
    ))
    //按course分组
    val courseAndScore = lines.map(line => {
      val arr = line.split("\\s+")
      var course = arr(0)
      var score = arr(1) + "|" + arr(2)
      (course, score)
    }).groupByKey(numPartitions = 1)
    //分组排序前
    courseAndScore.foreach{case(course,score)=>{
      println(s"${course}--${score.mkString(",")}")
    }}
    //分组排序
    //map每次进入一个分组，对一组中的score迭代器操作
    //先将score迭代器转成list
    val courseScoreSort = courseAndScore.map { case (course, score) => {
      val listScore = score.toList
      //对list排序，取list中每个元素s1,s2的成绩排序
      val scoreSort = listScore.sortWith((s1, s2) => {
        val score1 = s1.split("\\|")(1)
        val score2 = s2.split("\\|")(1)
        score1 > score2//降序
      })
      //返回排序结果
      (course, scoreSort)
    }
    }
    //分组排序后
    courseScoreSort.foreach{case(course,score)=>{
      println(s"${course}--${score.mkString(",")}")
    }}
  }

}

3.4.分组排序求topN优化

sortWith排序，combineByKey优化

object Demo4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Demo3")
      .setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(List(
      "chinese ls 91",
      "english ww 56",
      "chinese zs 90",
      "chinese zl 76",
      "english zq 88",
      "chinese wb 95",
      "chinese sj 74",
      "english ts 87",
      "english ys 67",
      "english mz 77",
      "chinese yj 98",
      "english gk 96"
    ))
    //按course分组---优化，使用combinebykey预聚合
    val courseAndScore = lines.map(line => {
      val arr = line.split("\\s+")
      var course = arr(0)
      var score = arr(1) + "|" + arr(2)
      (course, score)
    }).combineByKey(createCombiner,mergeValue,mergeCombiners)

    //分组排序前
    courseAndScore.foreach{case(course,score)=>{
      println(s"${course}--${score.mkString(",")}")
    }}
    //分组排序
    //map每次进入一个分组，对一组中的score迭代器操作
    //先将score迭代器转成list
    val courseScoreSort = courseAndScore.map { case (course, score) => {
      val listScore = score.toList
      //对list排序，取list中每个元素s1,s2的成绩排序
      val scoreSort = listScore.sortWith((s1, s2) => {
        val score1 = s1.split("\\|")(1)
        val score2 = s2.split("\\|")(1)
        score1 > score2//降序
      }).take(3)
      //返回排序结果
      (course, scoreSort)
    }
    }
    //分组排序后
    courseScoreSort.foreach{case(course,score)=>{
      println(s"${course}--${score.mkString(",")}")
    }}
  }
  def createCombiner(str:String): Array[String] ={
    Array(str)
  }
  def mergeValue(arr:Array[String],str:String):Array[String]={
    arr.:+(str)
  }
  def mergeCombiners(arr:Array[String],arr1:Array[String]):Array[String]={
    arr.++(arr1)
  }
}

3.5. 分组排序求topN最终

最终优化，combineByKey分组，treeset求topN

object Demo5 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Demo5")
      .setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(List(
      "chinese ls 91",
      "english ww 56",
      "chinese zs 90",
      "chinese zl 76",
      "english zq 88",
      "chinese wb 95",
      "chinese sj 74",
      "english ts 87",
      "english ys 67",
      "english mz 77",
      "chinese yj 98",
      "english gk 96"
    ))
    //按course分组---优化，使用combinebykey预聚合
    val courseAndScore = lines.map(line => {
      val arr = line.split("\\s+")
      var course = arr(0)
      var score = arr(1) + "|" + arr(2)
      (course, score)
    }).combineByKey(createCombiner,mergeValue,mergeCombiners)

    //显示排序结果
    courseAndScore.foreach{case(course,score)=>{
      println(s"${course}--${score.mkString(",")}")
    }}
    sc.stop()
  }

  def createCombiner(str:String): mutable.TreeSet[String]={
    mutable.TreeSet(str)(new Ordering[String] {
      override def compare(x: String, y: String): Int = {
        val s1 = x.split("\\|")(1)
        val s2 = y.split("\\|")(1)
        s1.compareTo(s2)
      }
    })
  }
  def mergeValue(tree:mutable.TreeSet[String],str:String):mutable.TreeSet[String]={
    //先add，treeset会自动排序，然后删除最后面的
    tree.add(str)
    if(tree.size>3){
      tree.dropRight(1)//此方法是有返回值的，生成一个新的set，所以要加上else，避免返回原set
    }else{
      tree
    }
  }
  def mergeCombiners(tree:mutable.TreeSet[String],tree1:mutable.TreeSet[String]):mutable.TreeSet[String]={
    for(a<-tree1){
      tree.add(a)
    }
    if(tree.size>3){
      tree.dropRight(tree.size-3)
    }else{
      tree
    }

  }
}

3.6. 分区

/**
 * Spark rdd操作分区
 * 涉及到分区的操作，主要集中在这么几处：
 * 1、就是在输入操作
 *
 * 2、shuffle操作的时候会有分区的操作
 *
 * spark提供的分区方式，默认有2种：
 *  HashPartitioner（默认的）
 *  RangePartitioner(输入算子通常所使用)
 *
 * 自定义分区操作
 *
 *  需求：按照每一个科目一个文件，将数据进行重新的划分
 *      显然这就得需要用到重分区操作，但是该重分区不是repartition或者coleasce
 *  在spark rdd的操作中有一个算子专门可以进行分区--partitionBy
 *    当然，除了该算子以外，其他的只要是shuffle操作，通常都会有第二个参数，叫partitioner，也可以通过该参数来完成分区
 *
 */
object Demo1 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("Demo1")
      .setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(List(
      "chinese ls 91",
      "english ww 56",
      "chinese zs 90",
      "math zl 76",
      "english zq 88",
      "chinese wb 95",
      "chinese sj 74",
      "english ts 87",
      "math ys 67",
      "english mz 77",
      "chinese yj 98",
      "english gk 96",
      "math zq 88",
      "chinese wb 95",
      "math sj 74",
      "english ts 87",
      "math ys 67",
      "english mz 77",
      "math yj 98",
      "english gk 96"
    ))
    val map = lines.map(line => {
      val i = line.indexOf(" ")
      val course = line.substring(0, i)
      val score = line.substring(i + 1)
      (course, score)
    })
    val array = map.keys.distinct().collect()
    map.partitionBy(new Mypartition(array)).saveAsTextFile("C:\\Users\\70201\\Desktop\\test\\partition")




    sc.stop()
  }


}
class Mypartition(keys:Array[String]) extends Partitioner {
  val key2PartitionId = {

    val map = mutable.Map[String, Int]()
    for(i <- 0 until keys.length) {
      map.put(keys(i), i)
    }
    map
  }
  //最后的分区的个数
  override def numPartitions: Int = keys.length
  //将对应的key映射到相匹配的partitionId
  override def getPartition(key: Any): Int = {
    key2PartitionId.getOrElse(key.toString, 0)
  }
}

4.spark总结

在这里插入图片描述

在这里插入图片描述

Spark避坑系列二（Spark Core-RDD编程）
艺术架构
01-09 1055
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，代表一个不可变、可分区、里面的元素可并行计算的集合。
Spark避坑系列（三）（Spark Core-RDD 依赖关系&持久化&共享变量）
最新发布
艺术架构
01-11 507
该篇章主要介绍spark的编程核心RDD的其他概念，依赖关系，持久化，广播变量，累加器等
Hive中的四种排序方式（order by,sort by,distribute by,cluster by）使用与区别详解
热门推荐
weixin_43230682的博客
07-14 1万+
在平时的Hive数仓开发工作中经常会用到排序，而Hive中支持的排序方式有四种，这里结合具体的案例详细介绍一下他们的使用与区别： order by sort by distribute by cluster by 一、order by（全局排序） 1、作用：全局排序，只有一个reducer。 order by 会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序），也正因为只有一个reducer，所以当输入的数据规模较大时会导致计算时间较长。 　　set hive.mapr
hive中order by 、sort by、distribute by、cluster by区别
mo
06-15 1350
1.Order By：全局排序，只有一个Reducer，所以当数据量很大的时候用order by会比较慢。 2.sort by:区内排序，每个Reducer内部进行排序，对全局结果集来说不是排序。 (使用sort by的话前提要设置一下reduce个数,set mapreduce.job.reduces=n,n为reduce的个数，n>1) 例如按照部门编号从高到低进行排序，这里我的reduce设置的是3。 原表数据 sort by 之后 insert overwrite local directo
大数据之Hive：hive中的四个by
weixin_43597208的博客
06-16 4347
目录1.前言2.order by3.sort by4.distribute by5.Cluster By6.实际需求 1.前言 hive中的四个by分别为order by，sort by，distribute by，cluster by； 下面具体讲解： 2.order by 全局排序，只有一个reduce； 缺点：当数据量非常大时，耗时太长，效率低下，适用于数据量较小的场景； 优点：数据全局排序； select * from emp order by sal desc; 备注:当你使用order by时
hive的四个by
qq_40839450的博客
05-31 611
1.order bycol_list： 全局排序，默认为升序asc ,因此只有一个reducer,只有一个reduce task的结果， 比如文件名是000000_0,会导致当输入规模较大时，需要较长的计算时间。 如果指定了hive.mapred.mode=strict（默认值是nonstrict）,这时就必须指定limit来限制输出条数，原因是：所有的数据都会在同一个reducer端进行，数据量大的情况下可能不能出结果，那么在这样的严格模式下，必须指定输出的条数。 对被排序列进行全排序...
Hive的四个排序 by 总结
iiiitttttt的博客
03-29 2272
Hive的四个排序 by 总结 Order by (全局排序) 全局排序 全局只有一个Reducer Sort by (分区内排序) 分区内排序 Distrbute By(分区间排序) 分区间排序 类似MR中Partition，进行分区，结合sort by使用。 Cluseter 当Distribute by和Sorts by字段相同时，可以使用Cluster by方式。Cluster by除了具有Distribute by的功能外还兼具Sort by的功能。但是排序只能
2.SparkCore-RDD编程
weixin_44085996的博客
09-15 214
二、 RDD编程 1、编程模型 在Spark中，RDD被表示为对象，通过对象上的方法调用来对RDD进行转换。经过一系列的transformations定义RDD之后，就可以调用actions触发RDD的计算，action可以是向应用程序返回结果(count, collect等)，或者是向存储系统保存数据(saveAsTextFile等)。在Spark中，只有遇到action，才会执行RDD的计算(即延迟计算)，这样在运行时可以通过管道的方式传输多个转换。 要使用Spark，开发者需要编写一个Drive
SparkCore-RDD编程
wuyangcc的博客
04-17 273
SparkCore-RDD编程操作 0. 大纲 Spark程序的执行过程 RDD的操作 RDD的转换操作 共享变量 高级排序 1. Spark程序执行过程 1.1. WordCount案例程序的执行过程 1.2. Spark程序执行流程 2. RDD的操作 ​ At a high level, every Spark application consists of a dri...
【SparkCore篇01】RDD编程入门1
08-04
总的来说，Spark的RDD编程模型提供了一种灵活、高效的并行计算框架，通过血缘关系、缓存和检查点实现容错和性能优化。开发者通过定义transformations构建RDD的计算流程，并通过actions触发实际的计算。这种延迟计算...
Hive的四种排序
Hello_babypan的博客
08-29 412
排序 一、Order by 全局排序，一个Reduce来处理 正常排序：ASC 升序（默认） DESC 降序 二、Sort By 每个Reducer内部进行排序 设置reduce个数：set mapreduce.job.reduce=3; 查看设置reduce个数： set mapreduce.job.reduce; 例：根据部门编号降序查看员工信息 select * from emp sort by empno desc 三、分区排序 distribute by 例：先按照部门编号分区，
hive中的sort by
朝着梦想 渐行前进
05-26 3881
hive中的sort by
HIVE的四种排序：Sort By,Order By,Cluster By,Distrbute By的作用和区别
唐豌豆的博客
09-19 1673
文章目录HIVE的四种排序一、order by二、sort by三、distribute by 和 sort by 一起使用四、cluster by HIVE的四种排序 一、order by hive中的order by 跟传统的sql语言中的order by 作用是一样的，会对查询的结果做一次全局排序。所以说，只有Hive的sql中制定了order by 所有的数据都会到同一个reduce中进行处理（不管有多少个map,也不论文件分成了多少block,有且仅有一个reduce,这是order by在处特
Hive中4个By Sort By 、Order By、Distrbute By、 Cluster By区别
ganghaodream的博客
08-08 1392
1）SortBy：分区内有序； 2）Order By：全局排序，只有一个Reducer； 3）Distrbute By：类似MR中Partition，进行分区，结合sort by使用。 4）Cluster By：当Distribute by和Sorts by字段相同时，可以使用Cluster by方式。Cluster by除了具有Distribute by的功能外还兼具Sort by的功能。但是排序只能是升序排序，不能指定排序规则为ASC或者DESC。 ...
hive的排序函数（hive之四by）
渐宽阁读书小弟
05-16 1032
hive的四种排序函数介绍
一句话搞懂Hive的4个BY排序
大数据技术学习
09-25 1094
Hive的4个BY排序和实际应用中的使用 Order BY 全局排序，生产环境基本不用，数据量太大 Sort BY 分区内排序 Distrbute By类似MR中Partition，进行分区生产环境sort by 和distrbute by 组合用的多 Cluster By 当Distribute by和Sorts by字段相同时，可以使用Cluster by方式。Cluster by除了具有Distribute by的功能外还兼具Sort by的功能。但是排序只能是升序排序，..
Hive中的四种排序
象在舞的技术专栏
09-01 6310
一、Order by order by会对输入的数据做全局排序，因此只有一个reducer，多个reducer无法保证全局有序。只有一个reducer的弊端在于当输入的数据量较大时，需要较长的计算时间。order by跟数据库中的order by功能一致，按照某一项或几项排序输出。它与数据库中 order by 的区别在于在hive.mapred.mode = strict 模式下
Hive中4个By的区别?
m0_61607827的博客
04-20 1300
1、Sort By:分区内有序 2、Order By:全局排序，只有一个Reducer 3、Distrbute By：类似MR中的Partition，进行分区，结合sort by使用 4、Cluster By：当Distrbute By和Sort By字段相同时，可以使用Cluster By方式。Cluster By除了具有Distrbute By的功能还有Sort By的功能。但是排序只能是升序排序，不能指定排序规则为ASC或者DESC。 窗口函数： RANK()排序相同时会重复，总数不会变
Hive中4个By的区别
Laoddaaa的博客
08-14 596
Hive中的4个By的作用和区别。
Spark Core：理解RDD：弹性分布式数据集与操作原理
Spark Core中的核心概念是RDD（Resilient Distributed Dataset，弹性分布式数据集）。RDD是Spark编程模型的基础，它是一种抽象数据结构，代表了一个不可变、可分区且元素可以并行计算的集合。它在设计上具有以下关键...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值