sparkCore之sparkRDD常用算子

最新推荐文章于 2023-11-23 21:15:05 发布

moshang_find

最新推荐文章于 2023-11-23 21:15:05 发布

阅读量707

点赞数

分类专栏： spark 文章标签： spark常用算子 spark Transformation算子 spark 常用Action算子 spark算子代码实例讲解

本文链接：https://blog.csdn.net/moshang_3377/article/details/92852414

版权

spark 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

前言： sparkRDD的操作，从宏观上分为：Transformation和Action，但是具体的还以分为：输入算子、变换算子、缓存算子，以及行动算子。
官网地址：
https://spark.apache.org/docs/latest/rdd-programming-guide.html#resilient-distributed-datasets-rdds

一、Transformation

先来官网的常用Transformation算子的截图：
在这里插入图片描述

下面呢，咱们也来列举几个常用的Transformation算子

1、flatMap

flatMap是Spark RDD中的转换算子，对RDD中的每一个元素都执行，前后元素的对应关系是OneToMany。也就是说，对一个元素执行RDD的操作，可以产生多个元素。

🌰:
    /**
      * 主要作用就是做拆分
      *    one2many
      * 将字符串进行单词的拆分
      */
    def flatMapOps: Unit = {
        val conf = new SparkConf()
                .setAppName("SparkFlatmap")
                .setMaster("local[*]")
        val sc = new SparkContext(conf)
        val list = List(
            "yao xin xin",
            "zhang zha ping"
        )
        val listRDD = sc.parallelize(list)
        val wordsRDD = listRDD.flatMap(line => line.split("\\s+"))
        wordsRDD.foreach(println)
        sc.stop()
    }

2、map

map是Spark RDD中的转换算子，对RDD中的每一个元素都执行，前后元素的对应关系是OneToOne。也就是说，对一个元素执行RDD的操作，可以产生一个元素。

🌰:
    /**
      * 将集合中的每一个元素*7
      */
    def mapOps(): Unit = {
    	val conf = new SparkConf()
                .setAppName("SparkMap")
                .setMaster("local[*]")
        val sc = new SparkContext(conf)
        val list = 1 to 7

        val listRDD = sc.parallelize(list)
        val retRDD = listRDD.map(_ * 7)
        retRDD.foreach(println)
    }

3、filter

对RDD中的每一个元素执行对应的func函数，保留该func函数返回值为true的元素，组成一个新的RDD，过滤掉返回值为false的元素。

🌰:
  //通过filter算子将list中以0结尾的学生筛选出来
  def filterOps(): Unit ={
  	val conf = new SparkConf()
                .setAppName("SparkFilter")
                .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val stuList = List(
      "1 zhangsan  18  0",
      "2 lisi  28  1",
      "3 wangwu  16  0",
      "4 xiaobai  23  1"
    )
    val stuRDD:RDD[String] = sc.parallelize(stuList)

    stuRDD.filter(_.endsWith("0")).foreach(println)
  }

4、sample

sample是Spark中的抽样算子，从RDD中抽取一定比例的数据，接收三个参数：

withReplacement: Boolean, true有放回的抽样, false无放回的抽样
fraction:Double，样本空间大小，占总大小的比例的分数的表现形式，20%->0.2
seed: Long ，抽样过程中的随机数种子。

注意：该抽样算子sample是非准确式的抽样，比如加入rdd中有1000个记录，抽取0.2的数据，按理结果应该有200个，真实结果可能会在200上下左右浮动。
sample算子的作用就是，对整体空间做一个大概的预估，key或者数据的分布情况，在解决数据倾斜的时候有着非常重要的角色。

🌰:
def sampleOps(): Unit ={
	val conf = new SparkConf()
                .setAppName("SparkSample")
                .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val numList = 1 to 1000
    val numRDD = sc.parallelize(numList)
    numRDD.sample(false,0.2).foreach(println)
  }

5、union

在spark中的union操作，作用和DB中的union all的作用相同，不会去重。
union：返回两张表中去重之后的结果
union all：返回两张表的所有结果。

🌰:
def unionOps(): Unit ={
	val conf = new SparkConf()
                .setAppName("SparkUnion")
                .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val list1 = 1 to 10
    val list2 = 8 to 15
    val rdd1 = sc.parallelize(list1)
    val rdd2 = sc.parallelize(list2)
    val unionRDD = rdd1.union(rdd2)
    unionRDD.foreach(println)
  }

这个上张结果图大家看看吧：
在这里插入图片描述

6、join

join是表的关联操作，这里的表示泛化的概念，只要是数据集都可以理解为表。
那么join有哪些操作呢？

	交叉连接：across join 写sql的时候有表的关联，但是没有on的连接字段，这会造成笛卡尔积。
	select a.* , b.*  from A a across join B b

    内连接:	inner（通常可省略） join，又被称为等值连接，返回左右表中都有的内容。
	select a.* , b.* from A a inner join B b on a.id = b.aid;

    select a.* , b.* from A a, B b where a.id = b.aid;

     外连接 outer join 非等值连接

		左外连接：left outer join 返回左表所有数据，右表没有显示为null

		select a.* , b.* from A a left outer join B b on a.id = b.aid;

		右外连接: right outer join返回右表所有数据，左表没有显示为null

		select a.* , b.* from A a right outer join B b on a.id = b.aid;

	半连接 semi join

	全连接 full outer join 全连接： left outer join + right outer join

说明：经过内连接join操作之后的数据是确定的。外连接操作之的数据是确定的吗？不确定，有可能有，有可能没有，所以数据类型是-----Option。

🌰:
/**
    * stu表
    *     id name age  class
    * 成绩表
    *     id sid  course  score
    *
    * 查询有成绩的学生的所有的信息-->inner
    *   select
            s.*, s1.*
          from stu s
          inner join score s1 on s.id = s1.sid
    * 查询所有学生的成绩
    *   select
    *     s.*, s1.*
    *   from stu s
    *   left join s1 on on s.id = s1.sid
    * 所有的join操作，必须要求的RDD的类型时<K, V>
    * K就是关联字段
    */
  def joinOps(): Unit ={
  	val conf = new SparkConf()
                .setAppName("SparkJoin")
                .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val stu = List(
      "1 zhangsan  22  bj",
      "2 lisi  25  bj",
      "3 wangwu  24  sz",
      "4 liliu 18  wh"
    )

    val scores = List(
      "1 1 math 82",
      "2 1 english 0",
      "3 2 chinese 85.5",
      "4 3 PE 99",
      "5 10 math 99"
    )
    val stuRDD = sc.parallelize(stu)
    val scoresRDD = sc.parallelize(scores)
    //查询所有学生的信息
    val sid2StuInfoRDD:RDD[(String,String)] = stuRDD.map(stuLine =>{
      val sid = stuLine.substring(0,1)
      val stuInfo = stuLine.substring(1).trim
      (sid,stuInfo)
    })

    val sid2ScoreInfo:RDD[(String,String)] = scoresRDD.map(scoreLine =>{

      val fields = scoreLine.split("\\s+")
      val sid = fields(1)
      val scoreInfo = fields(2)+" "+fields(3)
      (sid,scoreInfo)
    })
    val joinedRDD:RDD[(String, (String, String))] = sid2StuInfoRDD.join(sid2ScoreInfo)
    joinedRDD.foreach(println)
    println("-------------------------------------------")
    joinedRDD.foreach{case (sid,(stuInfo,scoreInfo)) =>{
      println(s"sid:${sid}\tstuInfo:${stuInfo}\tscoreInfo:${scoreInfo}")
    }
    }
    println("-------------------------------------------")
    val leftJoined:RDD[(String, (String, Option[String]))] = sid2StuInfoRDD.leftOuterJoin(sid2ScoreInfo)
    leftJoined.foreach{case (sid, (stuInfo, option)) => {
      println(s"sid:${sid}\tstuInfo:${stuInfo}\tscoreInfo:${option.getOrElse(null)}")
    }}
  }

7、groupByKey

对rdd中的数据按照key进行分组，首先必须要有key，rdd的数据类型就必须是(K, V),经过分组之后相同的key的数据拉取到一起，组成了一个集合。

(K, V).groupByKey() --> (K, Iterable[V])

不建议使用这个groupByKey，可以使用reduceByKey或者aggregateByKey来代替groupByKey。因为性能差，没有本地combiner。

🌰:
def groupByKeyOps(): Unit ={
	val conf = new SparkConf()
                .setAppName("Sparkgbk")
                .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val stu = List(
      "1 zhangsan  22  class-bj",
      "2 lisi  25  class-bj",
      "3 zhangsi  24  class-sz",
      "4 wangwu 18  class-wh",
      "5 zhoujielun 18  class-wh",
      "4 zhangxixi 18  class-sz"
    )
    val stuRDD:RDD[String] = sc.parallelize(stu)
    val class2Info:RDD[(String, String)] = stuRDD.map(stuLine => {
      val clazz = stuLine.substring(stuLine.indexOf("class"))
      val info = stuLine.substring(0, stuLine.indexOf("class")).trim
      (clazz, info)
    })
    val gbkRDD:RDD[(String, Iterable[String])] = class2Info.groupByKey()
    gbkRDD.foreach{case (clazz, info) => {
      println(s"${clazz}--->${info}")
    }
    }
    println("-----------------------------------------")
    //ClassTag是类型的标记接口
    val gbRDD:RDD[(String, Iterable[String])] = stuRDD.groupBy(stuLine => stuLine.substring(stuLine.indexOf("class")))(
      ClassTag.Object.asInstanceOf[ClassTag[String]]
    )
    gbRDD.foreach{case (clazz, info) => {
      println(s"${clazz} ===> ${info}")
    }}
  }

8、reduceByKey

按照key执行reduce操作，也要求数据类型(K, V) —> (K, V)

🌰:
    def rbkOps(): Unit = {
    	val conf = new SparkConf()
                .setAppName("Sparkrbk")
                .setMaster("local[*]")
    	val sc = new SparkContext(conf)
        val list = List(
            "zhang san     san",
            "zhao zhao ling"
        )

        val listRDD = sc.parallelize(list)
        val wordsRDD = listRDD.flatMap(line => line.split("\\s+"))
        val pairsRDD:RDD[(String, Int)]= wordsRDD.map((_, 1))
        val rbkRDD:RDD[(String, Int)] = pairsRDD.reduceByKey(_+_)
        rbkRDD.foreach(println)
    }

9、distinct

去重，即sql中的关键字distinct。

🌰:
    def distinctOps(): Unit = {
    	val conf = new SparkConf()
                .setAppName("SparkDistinct")
                .setMaster("local[*]")
    	val sc = new SparkContext(conf)
        val list = List(
            "张三",
            "张三",
            "张三",
            "张三"
        )
        val listRDD:RDD[String] = sc.parallelize(list)
        //numPartitions:在去重的时候指定几个分区-->task,也就是说同时运行几个task来进行去重
        listRDD.distinct(4).foreach(println)
    }

10、combineByKey（很重要）

reduceByKey和groupByKey底层都是通过combineByKeyWithClassTag来实现的，有一个简写方式combineByKey。

意为按照key进行聚合combine操作，聚合操作有很多，groupBy、reduceBy、count等等。

自定义的combineByKey。通过学习combineBykey模拟reduceByKey和groupByKey来理解什么是分布式计算。

10.1combineByKey模拟reduceByKey

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

object CombineByKey2ReduceBykey {
  def main(args: Array[String]) {
    val conf = new SparkConf()
      .setAppName("cbk2rb")
      .setMaster("local[*]")
    val sc = new SparkContext(conf)
    val list = List(
      "hello you hello me",
      "hello you hello me",
      "me an you"
    )

    val listRDD = sc.parallelize(list)
    val pairRDD:RDD[(String,Int)] =
     		listRDD.flatMap(_.split("\\s+")).map((_,1))

    //
    println("------------传统rbk操作--------------")
    pairRDD.reduceByKey(_+_).foreach(println)
    println("------------combineByKey模拟rbk操作--------------")
    pairRDD.combineByKey(createCombiner,mergeValue,mergeCombiners).foreach(println)
	//初始化聚合的结果类型
    def createCombiner(value: Int): Int ={
      value
    }
	//分区内的聚合操作（map端的操作）
    def mergeValue(sum: Int,value: Int): Int ={
       sum + value
    }
	//分区间的聚合操作(reduce端的操作)
    def mergeCombiners(sum1:Int,sum2:Int): Int ={
      sum1+sum2
    }
  }
}

10.2combineByKey模拟groupByKey

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

import scala.collection.mutable.ArrayBuffer

object CombineByKey2GroupByKeyOps {
  def main(args: Array[String]) {
    val conf = new SparkConf()
                .setAppName("cbk2gbk")
                .setMaster("local[2]")
    val sc = new SparkContext(conf)
    val stu = List(
      "1 zhangsan  22  bd-bj",
      "2 lisi  25  bd-bj",
      "8 wangwu  24  bd-sz",
      "3 zhangyaoshi  24  bd-sz",
      "4 hudada 18  bd-wh",
      "6 chenpingan  25  bd-bj",
      "7 zhaoguang  25  bd-bj",
      "5 zhaoyun 18  bd-wh",
      "4 zhangfei 18  bd-sz"
    )

    //按照班级进行分组-->sql中的groupBy
    val stuRDD=sc.parallelize(stu)
    val class2Info:RDD[(String,String)]=stuRDD.map(stuLine =>{
      val clazz = stuLine.substring(stuLine.indexOf("bd"))
      (clazz,stuLine)
    })
    //class2Info.saveAsTextFile("file:///Users/wangjinqi/Desktop/out")
    val gbkRDD:RDD[(String,Iterable[String])]=class2Info.groupByKey()

    println("---------传统的gbk操作---------")
    gbkRDD.foreach{case(clazz,info)=>{
      println(s"${clazz}--->${info}")
    }
    }
    println("-------combineByKey模拟gbk操作----------")

    class2Info.combineByKey(
      (info:String) => createCombiner(info),
      (buffer:ArrayBuffer[String], info:String) => mergeValue(buffer, info),
      (buffer1:ArrayBuffer[String], buffer2:ArrayBuffer[String]) => mergeCombiners(buffer1, buffer2)
    ).foreach(println)
    sc.stop()
  }
  /*
      初始化操作，确定聚合操作之后的结果类型
      在每一个分区内相同的key，需要调用一次该操作，并将其中的一个元素用于初始化操作
   */
  def createCombiner(info:String):ArrayBuffer[String] ={
    println("createCobiner--->info:"+info)
    val ab = ArrayBuffer[String]()
    ab.append(info)
    ab
  }

  /**
    * 分区内的相同key的聚合操作
    *
    */
  def mergeValue(ab:ArrayBuffer[String],info:String): ArrayBuffer[String] ={
    println(s"mergeValue--->ab:${ab.mkString(",")}---info:${info}")
    ab.append(info)
    ab
  }

  /**
    * 分区间的相同key的聚合操作
    */
  def mergeCombiners(ab1:ArrayBuffer[String],ab2:ArrayBuffer[String]): ArrayBuffer[String] ={
    println(s"mergeCombiners------>ab1:${ab1.mkString(",")}---ab2:${ab2.mkString(",")}")
    ab1 ++ ab2
  }
}

11、aggregateByKey（很重要）

aggregateBykey本质和combineByKey一样的。使用方面，只是在参数传递的方面略有差异。

11.1 aggregateBykey模拟groupByKey

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

import scala.collection.mutable.ArrayBuffer

object AggregateByKey2GroupByKeyOps {
  def main(args: Array[String]) {
    val conf = new SparkConf()
      .setAppName("abk2gbk")
      .setMaster("local[2]")
    //thread -- task--->partition(block)
    val sc = new SparkContext(conf)
    val stu = List(
      "1 liushuai  22  bd-bj",
      "2 zhangsan  25  bd-bj",
      "8 lisi  24  bd-sz",
      "3 wangwu  24  bd-sz",
      "4 zhangfei 18  bd-wh",
      "6 caocao  25  bd-bj",
      "7 zhugekongming  25  bd-bj",
      "5 zhouyu 18  bd-wh",
      "4 xiaoqiao 18  bd-sz"
    )
    //按照班级进行分组 -->sql中的groupBy
    val stuRDD = sc.parallelize(stu)
    val class2Info:RDD[(String,String)]=stuRDD.map{stuLine =>{
      val clazz = stuLine.substring(stuLine.indexOf("bd"))
      (clazz,stuLine)
    }}
    val gbkRDD:RDD[(String,Iterable[String])]=class2Info.groupByKey()
    println("-----------传统的gbk操作--------------")
    gbkRDD.foreach{case(clazz,info)=>{
      println(s"${clazz}--->${info}")
    }
    }
    println("-----------aggregateByKey模拟gbk操作--------------")
    class2Info.aggregateByKey(ArrayBuffer[String]())(seqOp, combOp).foreach(println)
  }

  def seqOp(ab:ArrayBuffer[String],info:String):ArrayBuffer[String] ={
    ab.append(info)
    ab
  }

  def combOp(ab1:ArrayBuffer[String],ab2:ArrayBuffer[String]):ArrayBuffer[String]={
    ab1 ++ ab2
  }
}

11.2.aggregateBykey模拟reduceByKey

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

import scala.collection.mutable.ArrayBuffer


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


    val list = List(
      "hello you hello me",
      "hello you shit me",
      "hello you oh shit",
      "me you hello me"
    )
    val listRDD = sc.parallelize(list)
    val pairsRDD:RDD[(String, Int)] = listRDD.flatMap(_.split("\\s+")).map((_, 1))

    //reduceByKey
    println("-----------传统的rbk操作--------------")
    pairsRDD.reduceByKey(_+_).foreach(println)
    println("-----------combineByKey模拟rbk操作--------------")

    pairsRDD.aggregateByKey(0)(seqOp, combOp).foreach(println)
    //pairsRDD.aggregateByKey(0)((sum1, i) => sum1 + i, (sum, sum1) => sum + sum1).foreach(println)
    //pairsRDD.aggregateByKey(0)(_+_, _+_).foreach(println)
    sc.stop()
  }

  def seqOp(sum:Int, i:Int): Int = {
    sum + i
  }

  def combOp(sum1:Int, sum2:Int): Int = {
    sum1 + sum2
  }
}

二、Action

action操作，是行动算子，是触发spark作业执行的动因。
同样，还是先来官网的常用Action算子的截图：
在这里插入图片描述

1、foreach

一般foreach的执行方式是foreach(func)，对数据集的每个元素运行函数func。

2、collect

以数组的形式将所有数据集合的结果拉取到客户端，慎用，避免出现OOM，一般在使用该算子之前需要进行一个filter过滤掉部分数据或者使用take来决定需要拉取数据的量。

3、count

返回元素集合的数据条数

4、saveAsTextFile/saveAsHadoopFile/saveAsHadoopAPIFile

🌰:
        /*
            saveAsTextFile
                将rdd以普通文本的方式进行存储，存储的格式()
         */
//        retRDD.saveAsTextFile("file:///E:/data/out/astf")
        /*
            saveAsSequenceFile
                将rdd以sequenceFile的格式存储
         */
//        retRDD.saveAsSequenceFile("file:///E:/data/out/sequ", Option(classOf[DefaultCodec]))
        /*
            saveAsHadoopFile
            saveAsNewHadoopAPIFile
                都是使用的hadoop的格式化输出OutputFormat 这两个方法的区别主要就是OutputFormat的区别
                saveAsHadoopFile --> org.apache.hadoop.mapred.OutputFormat
                saveAsNewHadoopAPIFile --> org.apache.hadoop.mapreduce.OutputFormat
         */
        retRDD.saveAsNewAPIHadoopFile("file:///E:/data/out/hadoop",
                classOf[Text],
                classOf[IntWritable],
                classOf[TextOutputFormat[Text, IntWritable]]
            )

5、take(n)/frist/takeOrdered

take获取集合中的前N个值，take(1)=first,如果说这个集合是有序的，take(n)–等效于–>TopN
takeOrdered是使用RDD的自然顺序或自定义比较器返回RDD的前n个元素。

🌰:
println("-------take(2)-------------")
retRDD.take(2).foreach(println)
println("-------first-------------")
println(retRDD.first())
println("--------takeOrdered----------------------")
implicit val order = new Ordering[(String, Int)](){
    override def compare(x: (String, Int), y: (String, Int)) = {
        var ret = y._2.compareTo(x._2)
        if(ret == 0) {
            ret = y._1.compareTo(x._1)
        }
        ret
    }
}
retRDD.takeOrdered(5).foreach(println)

6、countByKey

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

object countByKeyOps {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("actionOps")
      .setMaster("local[1]")
    val sc = new SparkContext(conf)
    
    val list = List(
      "hello you hello me",
      "hello you shit me",
      "hello you oh shit",
      "me you hello me"
    )

    val listRDD = sc.parallelize(list)

    val pairsRDD: RDD[(String, Int)] = listRDD.flatMap(_.split("\\s+")).map((_, 1))

    val retRDD: RDD[(String, Int)] = pairsRDD.reduceByKey(_ + _)
    //通过每个key出现的次数
    val k2counts = pairsRDD.countByKey()
    for ((k, v) <- k2counts) {
      println(s"${k}---$v")
    }
    //使用groupByKey、reduceByKey、countByKey   --->wordcount
    println("-----------------------------------")
    val gbks = pairsRDD.groupByKey()
    //        gbks.foreach(println)
    gbks.map { case (key, values) => (key, values.size) }.foreach(println)
  }
}

7、reduce

reduceByKey是一个transformation，reduce是一个action。需要注意区分！

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

    val list = List(
      "hello you hello me",
      "hello you shit me",
      "hello you oh shit",
      "me you hello me"
    )

    val listRDD = sc.parallelize(list)

    val pairsRDD: RDD[(String, Int)] = listRDD.flatMap(_.split("\\s+")).map((_, 1))

    val sum = pairsRDD.values.reduce(_+_)
    println(sum)
  }
}

moshang_find

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
sparkCore之sparkRDD常用算子

前言： sparkRDD的操作，从宏观上分为：Transformation和Action，但是具体的还以分为：输入算子、变换算子、缓存算子，以及行动算子。官网地址：https://spark.apache.org/docs/latest/rdd-programming-guide.html#resilient-distributed-datasets-rdds
复制链接

扫一扫