Spark中RDD概述及RDD算子详解

一、RDD概述

1、RDD: 弹性的分布式数据集

弹性:RDD 中的数据即可以缓存在内存中, 也可以缓存在磁盘中, 也可以缓存在外部存储中

分布式:数据可以分布在多台服务器中,RDD中的分区来自于block块,而block块会来自不同的datanode

数据集:(1)RDD自身可以不存储数据的,只存放代码计算逻辑,触发作业执行的时候,数据会在RDD之间流动

(2)RDD 也可以缓存起来, 相当于存储具体数据

2、 RDD 是一个分布式 计算框架, 所以, 一定是要能够进行分区计算的, 只有分区了, 才能利用集群的并行计算能力

二、shuffle

spark的运行过程中如果出现了相同的键被拉取到对应的分区,这个过程称之为shuffle。

注:只有 Key-Value 型的 RDD 才会有 Shuffle 操作,Spark的shuffle和mapreduce的shuffle原理是一样,都是要进行落盘。

Scala 复制代码
object Demo2Partition {
  def main(args: Array[String]): Unit = {
    //1、创建Spark环境
    //1.1 创建配置文件对象
    val conf: SparkConf = new SparkConf()

    //1.2 指定运行的模式(local  Standalone  Mesos  YARN)
    conf.setMaster("local") //可以执行所运行需要核数资源local[2],不指定的话默认使用所有的资源执行程序

    //1.3 给spark作业起一个名字
    conf.setAppName("wc")

    //2、创建spark运行时的上下文对象
    //SparkContext是spark-core的入口组件, 是一个 Spark 程序的入口,主要作用是连接集群, 创建 RDD, 累加器, 广播变量等
    val sparkContext: SparkContext = new SparkContext(conf)

    //3、读取文件数据
    //    val wordsLine: RDD[String] = sparkContext.textFile("spark/data/ws/*", minPartitions = 7)
    val wordsLine: RDD[String] = sparkContext.textFile("spark/data/ws/*")
    println(s"wordsLineRDD分区数是:${wordsLine.getNumPartitions}")

    //4、每一行根据|分隔符进行切分
    val words: RDD[String] = wordsLine.flatMap(_.split("\\|"))
    println(s"wordsRDD分区数是:${words.getNumPartitions}")

    val wordsTuple2: RDD[(String, Int)] = words.map((_, 1))
    println(s"wordsTuple2RDD分区数是:${wordsTuple2.getNumPartitions}")

    //产生shuffle的算子上可以单独设置分区数
    val wordsTuple2Group: RDD[(String, Iterable[(String, Int)])] = wordsTuple2.groupBy(_._1, 5)
    println(s"wordsTuple2GroupRDD分区数是:${wordsTuple2Group.getNumPartitions}")

    val wordCount: RDD[(String, Int)] = wordsTuple2Group.map((kv: (String, Iterable[(String, Int)])) => (kv._1, kv._2.size))
    println(s"wordCountRDD分区数是:${wordCount.getNumPartitions}")

    wordCount.saveAsTextFile("spark/data/word_count2")

  }
}

SparkContext是spark功能的主要入口其代表与spark集群的连接,能够用来在集群上创建RDD、累加器、广播变量。每个JVM里只能存在一个处于激活状态的SparkContext,在创建新的SparkContext之前必须调用stop()来关闭之前的SparkContext。

每一个Spark应用都是一个SparkContext实例,可以理解为一个SparkContext就是一个spark application的生命周期,一旦SparkContext创建之后,就可以用这个SparkContext来创建RDD、累加器、广播变量,并且可以通过SparkContext访问Spark的服务,运行任务。spark context设置内部服务,并建立与spark执行环境的连接。

sparkContext在Spark应用程序的执行过程中起着主导作用,它负责与程序和spark集群进行交互,包括申请集群资源、创建RDD、accumulators及广播变量等。

三、RDD五大特性

复制代码
1、RDD是由一些分区构成的,读取文件时有多少个block块,RDD中就会有多少个分区
注:默认情况下,所有的RDD中的分区数是一样的,无论是shuffle之前还是shuffle之后的,在最开始加载数据的时候决定的

2、函数实际上是作用在RDD中的分区上的,一个分区是由一个task处理,有多少个分区,总共就有多少个task

注:函数在spark中称之为算子(转换transformation算子 RDD-->RDD,行动action算子 RDD->Other数据类型)

3、RDD之间存在一些依赖关系,后一个RDD中的数据是依赖与前一个RDD的计算结果,数据像水流一样在RDD之间流动

注:

3.1 RDD之间有两种依赖关系

a. 窄依赖 后一个RDD中分区数据对应前一个RDD中的一个分区数据 1对1的关系

b. 宽依赖 后一个RDD中分区数据来自前一个RDD中的多个分区数据 1对多的关系(shuffle)

3.2 因为有了依赖关系,将整个作业划分了一个一个stage阶段 sumNum(stage) = Num(宽依赖) + 1

3.3 窄依赖的分区数是不可以改变,取决于第一个RDD分区数,宽依赖可以在产生shuffle的算子上设置分区数

4、分区类的算子只能作用在键值对格式的RDD上,groupByKey、reduceByKey

5、spark为task计算提供了精确的计算位置,移动计算而不移动数据

四、RDD算子

RDD 中的算子从功能上分为两大类

  1. Transformation(转换) :它会在一个已经存在的 RDD 上创建一个新的 RDD, 将旧的 RDD 的数据转换为另外一种形式后放入新的 RDD

  2. Action(行动): 执行各个分区的计算任务, 将的到的结果返回到 Driver 中

注意:RDD具有懒执行的特点,一个spark作业,由action算子来触发执行的,若没有action算子,整个作业不执行

转换算子:Transformation

1、Map算子

将rdd中的数据,一条一条的取出来传入到map函数中,map会返回一个新的rdd,map不会改变总数据条数

Scala 复制代码
object Demo3Map {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("map算子演示")
    val context = new SparkContext(conf)
    //====================================================

    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    /**
     * map算子:将rdd中的数据,一条一条的取出来传入到map函数中,map会返回一个新的rdd,map不会改变总数据条数
     */
    val splitRDD: RDD[List[String]] = studentRDD.map((s: String) => {
      println("============好好学习================")
      s.split(",").toList
    })

//    splitRDD.foreach(println)     //foreach是action算子       
  }
}

2、filter算子

filter: 过滤,将RDD中的数据一条一条取出传递给filter后面的函数,如果函数的结果是true,该条数据就保留,否则丢弃

Scala 复制代码
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object Demo4Filter {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("map算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    /**
     *  filter: 过滤,将RDD中的数据一条一条取出传递给filter后面的函数,如果函数的结果是true,该条数据就保留,否则丢弃
     *
     *  filter一般情况下会减少数据的条数
     */
    val filterRDD: RDD[String] = studentRDD.filter((s: String) => {
      val strings: Array[String] = s.split(",")
      "男".equals(strings(3))
    })


    filterRDD.foreach(println)

  }
}

3、flatMap算子

flatMap算子:将RDD中的数据一条一条的取出传递给后面的函数,函数的返回值必须是一个集合。最后会将集合展开构成一个新的RDD

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo5flatMap {
  def main(args: Array[String]): Unit = {

    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("flatMap算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val linesRDD: RDD[String] = context.textFile("spark/data/words.txt")

    /**
     *  flatMap算子:将RDD中的数据一条一条的取出传递给后面的函数,函数的返回值必须是一个集合。最后会将集合展开构成一个新的RDD
     */
    val wordsRDD: RDD[String] = linesRDD.flatMap((line: String) => line.split("\\|"))

    wordsRDD.foreach(println)
  }
}

4、sample算子

从前一个RDD的数据中抽样一部分数据,抽取的比例不是正好对应的,在抽取的比例上下浮动 比如1000条抽取10% 抽取的结果在100条左右

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo6sample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("flatMap算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    /**
     *  sample算子:从前一个RDD的数据中抽样一部分数据
     *
     *  抽取的比例不是正好对应的,在抽取的比例上下浮动 比如1000条抽取10% 抽取的结果在100条左右
     */
    val sampleRDD: RDD[String] = studentRDD.sample(withReplacement = true, 0.1)
    sampleRDD.foreach(println)
  }

}

5、groupBy算子

groupBy:按照指定的字段进行分组,返回的是一个键是分组字段,值是一个存放原本数据的迭代器的键值对 返回的是kv格式的RDD

Scala 复制代码
object Demo7GroupBy {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("groupBy算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    val splitRDD: RDD[Array[String]] = studentRDD.map((s: String) => s.split(","))

    //需求:求出每个班级平均年龄
    //使用模式匹配的方式取出班级和年龄
    val clazzWithAgeRDD: RDD[(String, Int)] = splitRDD.map {
      case Array(_, _, age: String, _, clazz: String) => (clazz, age.toInt)
    }

    /**
     *  groupBy:按照指定的字段进行分组,返回的是一个键是分组字段,值是一个存放原本数据的迭代器的键值对 返回的是kv格式的RDD
     *
     *  key: 是分组字段
     *  value: 是spark中的迭代器
     *  迭代器中的数据,不是完全被加载到内存中计算,迭代器只能迭代一次
     *
     *  groupBy会产生shuffle
     */
    //按照班级进行分组
    //val stringToStudents: Map[String, List[Student]] = stuList.groupBy((s: Student) => s.clazz)
    val kvRDD: RDD[(String, Iterable[(String, Int)])] = clazzWithAgeRDD.groupBy(_._1)
    val clazzAvgAgeRDD: RDD[(String, Double)] = kvRDD.map {
      case (clazz: String, itr: Iterable[(String, Int)]) =>
        //CompactBuffer((理科二班,21), (理科二班,23), (理科二班,21), (理科二班,23), (理科二班,21), (理科二班,21), (理科二班,24))
        //CompactBuffer(21,23,21,23,21,21,24)
        val allAge: Iterable[Int] = itr.map((kv: (String, Int)) => kv._2)
        val avgAge: Double = allAge.sum.toDouble / allAge.size
        (clazz, avgAge)
    }

    clazzAvgAgeRDD.foreach(println)

    while (true){

    }

  }

}

6、groupByKey算子

groupByKey: 按照键进行分组,将value值构成迭代器返回,在spark中看到RDD[(xx, xxx)] 这样的RDD就是kv键值对类型的RDD,只有kv类型键值对RDD才可以调用groupByKey算子。

Scala 复制代码
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object Demo8GroupByKey {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("groupByKey算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    val splitRDD: RDD[Array[String]] = studentRDD.map((s: String) => s.split(","))

    //需求:求出每个班级平均年龄
    //使用模式匹配的方式取出班级和年龄
    val clazzWithAgeRDD: RDD[(String, Int)] = splitRDD.map {
      case Array(_, _, age: String, _, clazz: String) => (clazz, age.toInt)
    }


    /**
     *  groupByKey: 按照键进行分组,将value值构成迭代器返回
     *  将来你在spark中看到RDD[(xx, xxx)] 这样的RDD就是kv键值对类型的RDD
     *  只有kv类型键值对RDD才可以调用groupByKey算子
     *
     */
    val kvRDD: RDD[(String, Iterable[Int])] = clazzWithAgeRDD.groupByKey()
    val clazzAvgAgeRDD: RDD[(String, Double)] = kvRDD.map {
      case (clazz: String, ageItr: Iterable[Int]) =>
        (clazz, ageItr.sum.toDouble / ageItr.size)
    }
    clazzAvgAgeRDD.foreach(println)

    while (true){

    }

    /**
     *  groupBy与groupByKey的区别(spark的面试题)
     *  1、代码上的区别:任意一个RDD都可以调用groupBy算子,只有kv类型的RDD才可以调用groupByKey
     *  2、groupByKey之后产生的RDD的结构比较简单,方便后续处理
     *  3、groupByKey的性能更好,执行速度更快,因为groupByKey相比较与groupBy算子来说,shuffle所需要的数据量较少
     */
  }
}

7、reduceByKey算子

按照键key对value值直接进行聚合,需要传入聚合的方式,reduceByKey算子也是只有kv类型的RDD才能调用。

Scala 复制代码
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object Demo9ReduceByKey {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("reduceByKey算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    val splitRDD: RDD[Array[String]] = studentRDD.map((s: String) => s.split(","))

    //求每个班级的人数
    val clazzKVRDD: RDD[(String, Int)] = splitRDD.map {
      case Array(_, _, _, _, clazz: String) => (clazz, 1)
    }

    /**
     * 利用groupByKey实现
     */
    //    val kvRDD: RDD[(String, Iterable[Int])] = clazzKVRDD.groupByKey()
    //    val clazzAvgAgeRDD: RDD[(String, Double)] = kvRDD.map {
    //      case (clazz: String, n: Iterable[Int]) =>
    //        (clazz, n.sum)
    //    }
    //    clazzAvgAgeRDD.foreach(println)

    /**
     * 利用reduceByKey实现:按照键key对value值直接进行聚合,需要传入聚合的方式
     * reduceByKey算子也是只有kv类型的RDD才能调用
     *
     *
     */
    val countRDD: RDD[(String, Int)] = clazzKVRDD.reduceByKey((x: Int, y: Int) => x + y)
    countRDD.foreach(println)



//    clazzKVRDD.groupByKey()
//      .map(kv=>(kv._1,kv._2.sum))
//      .foreach(println)

    while (true){

    }

    /**
     *  reduceByKey与groupByKey的区别
     *  1、reduceByKey比groupByKey在map端多了一个预聚合的操作,预聚合之后的shuffle数据量肯定是要少很多的,性能上比groupByKey要好
     *  2、从灵活角度来看,reduceByKey并没有groupByKey灵活
     *   比如reduceByKey无法做方差,groupByKey后续可以完成
     *
     */


  }
}

8、union算子

union:上下合并两个RDD,前提是两个RDD中的数据类型要一致,合并后不会对结果进行去重。这里的合并只是逻辑层面上的合并,物理层面其实是没有合并

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo10Union {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Union算子演示")
    val context = new SparkContext(conf)
    //====================================================
    val w1RDD: RDD[String] = context.textFile("spark/data/ws/w1.txt") // 1
    val w2RDD: RDD[String] = context.textFile("spark/data/ws/w2.txt") // 1

    /**
     *  union:上下合并两个RDD,前提是两个RDD中的数据类型要一致,合并后不会对结果进行去重
     *
     *  注:这里的合并只是逻辑层面上的合并,物理层面其实是没有合并
     */

    val unionRDD: RDD[String] = w1RDD.union(w2RDD)
    println(unionRDD.getNumPartitions) // 2

    unionRDD.foreach(println)
    while (true){

    }

  }
}

9、join算子

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
    /**
     *  内连接:join
     *  左连接:leftJoin
     *  右连接:rightJoin
     *  全连接:fullJoin
     */

object Demo11Join {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Join算子演示")
    val context = new SparkContext(conf)
    //====================================================

    //两个kv类型的RDD之间的关联
    //通过scala中的集合构建RDD
    val rdd1: RDD[(String, String)] = context.parallelize(
      List(
        ("1001", "尚平"),
        ("1002", "丁义杰"),
        ("1003", "徐昊宇"),
        ("1004", "包旭"),
        ("1005", "朱大牛"),
        ("1006","汪权")
      )
    )

    val rdd2: RDD[(String, String)] = context.parallelize(
      List(
        ("1001", "崩坏"),
        ("1002", "原神"),
        ("1003", "王者"),
        ("1004", "修仙"),
        ("1005", "学习"),
        ("1007", "敲代码")
      )
    )



    //内连接
//    val innerJoinRDD: RDD[(String, (String, String))] = rdd1.join(rdd2)
//    //加工一下RDD
//    val innerJoinRDD2: RDD[(String, String, String)] = innerJoinRDD.map {
//      case (id: String, (name: String, like: String)) => (id, name, like)
//    }
//    innerJoinRDD2.foreach(println)

    //左连接
    val leftJoinRDD: RDD[(String, (String, Option[String]))] = rdd1.leftOuterJoin(rdd2)
    //加工一下RDD
    val leftJoinRDD2: RDD[(String, String, String)] = leftJoinRDD.map {
      case (id: String, (name: String, Some(like))) => (id, name, like)
      case (id: String, (name: String, None)) => (id, name, "无爱好")
    }
    leftJoinRDD2.foreach(println)

    println("=================================")

    //右连接与左连接相差不多,不在赘述

    //全连接
    val fullJoinRDD: RDD[(String, (Option[String], Option[String]))] = rdd1.fullOuterJoin(rdd2)
    //加工一下RDD
    val fullJoinRDD2: RDD[(String, String, String)] = fullJoinRDD.map {
      case (id: String, (Some(name), Some(like))) => (id, name, like)
      case (id: String, (Some(name), None)) => (id, name, "无爱好")
      case (id: String, (None, Some(like))) => (id, "无姓名", like)
    }
    fullJoinRDD2.foreach(println)

  }

}

10、sortby算子

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo12Student {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("sortby算子演示")
    val context = new SparkContext(conf)
    //====================================================
    //需求:统计总分年级排名前10的学生的各科分数
    //读取分数文件数据
    val scoreRDD: RDD[(String, String, String)] = context.textFile("spark/data/score.txt") // 读取数据文件
      .map((s: String) => s.split(",")) // 切分数据
      .filter((arr: Array[String]) => arr.length == 3) // 过滤掉脏数据
      .map {
        //整理数据,进行模式匹配取出数据
        case Array(sid: String, subject_id: String, score: String) => (sid, subject_id, score)
      }

    //计算每个学生的总分
    val sumScoreWithSidRDD: RDD[(String, Int)] = scoreRDD.map {
      case (sid: String, _: String, score: String) => (sid, score.toInt)
    }.reduceByKey((x: Int, y: Int) => x + y)


    //按照总分排序
    val sumScoreTop10: Array[(String, Int)] = sumScoreWithSidRDD.sortBy(-_._2).take(10)

    //取出前10的学生学号
    val ids: Array[String] = sumScoreTop10.map(_._1)

    //取出每个学生各科分数
    val top10StuScore: RDD[(String, String, String)] = scoreRDD.filter {
      case (id: String, _, _) => ids.contains(id)
    }

    top10StuScore.foreach(println)

  }
}

11、mapValues算子

也是作用在kv类型的RDD上,主要的作用键不变,处理值

Scala 复制代码
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object Demo13MapValues {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Join算子演示")
    val context = new SparkContext(conf)
    //====================================================
    //需求:统计总分年级排名前10的学生的各科分数
    //读取分数文件数据
    val scoreRDD: RDD[(String, String, String)] = context.textFile("spark/data/score.txt") // 读取数据文件
      .map((s: String) => s.split(",")) // 切分数据
      .filter((arr: Array[String]) => arr.length == 3) // 过滤掉脏数据
      .map {
        //整理数据,进行模式匹配取出数据
        case Array(sid: String, subject_id: String, score: String) => (sid, subject_id, score)
      }

    //计算每个学生的总分
    val sumScoreWithSidRDD: RDD[(String, Int)] = scoreRDD.map {
      case (sid: String, _: String, score: String) => (sid, score.toInt)
    }.reduceByKey((x: Int, y: Int) => x + y)

    /**
     * mapValues算子:也是作用在kv类型的RDD上
     * 主要的作用键不变,处理值
     */
    val resRDD: RDD[(String, Int)] = sumScoreWithSidRDD.mapValues(_ + 1000)
    resRDD.foreach(println)

    //等同于
    val res2RDD: RDD[(String, Int)] = sumScoreWithSidRDD.map((kv: (String, Int)) => (kv._1, kv._2 + 1000))
  }
}

12、mapPartition算子

mapPartition: 主要作用是一次处理一个分区的数据,将一个分区的数据一个一个传给后面的函数进行处理

Scala 复制代码
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.rdd.RDD

object Demo14mapPartition {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("mapPartition算子演示")
    val context = new SparkContext(conf)
    //====================================================
    //需求:统计总分年级排名前10的学生的各科分数
    //读取分数文件数据
    val scoreRDD: RDD[String] = context.textFile("spark/data/ws/*") // 读取数据文件

    println(scoreRDD.getNumPartitions)

    /**
     *  mapPartition: 主要作用是一次处理一个分区的数据,将一个分区的数据一个一个传给后面的函数进行处理
     *
     *  迭代器中存放的是一个分区的数据
     */
//    val mapPartitionRDD: RDD[String] = scoreRDD.mapPartitions((itr: Iterator[String]) => {
//
//      println(s"====================当前处理的分区====================")
//      //这里写的逻辑是作用在一个分区上的所有数据
//      val words: Iterator[String] = itr.flatMap(_.split("\\|"))
//      words
//    })

//    mapPartitionRDD.foreach(println)

    scoreRDD.mapPartitionsWithIndex{
      case (index:Int,itr: Iterator[String]) =>
        println(s"当前所处理的分区编号是:${index}")
        itr.flatMap(_.split("\\|"))
    }.foreach(println)

  }

}

行动算子:Action

13、collect算子

以数组的形式返回数据集中所有元素

Scala 复制代码
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

object Demo15Actions {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("Action算子演示")
    val context = new SparkContext(conf)
    //====================================================

    val studentRDD: RDD[String] = context.textFile("spark/data/students.csv")

    /**
     * 转换算子:transformation 将一个RDD转换成另一个RDD,转换算子是懒执行的,需要一个action算子触发执行
     *
     * 行动算子(操作算子):action算子,触发任务执行。一个action算子就会触发一次任务执行
     */
    println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
    val studentsRDD: RDD[(String, String, String, String, String)] = studentRDD.map(_.split(","))
      .map {
        case Array(id: String, name: String, age: String, gender: String, clazz: String) =>
          println("****************************  ^_^ ********************************")
          (id, name, age, gender, clazz)
      }
    println("$$$$$$$$$$$$$$$$$$$$$$***__***$$$$$$$$$$$$$$$$$$$$$$$$$")

    // foreach其实就是一个action算子
//    studentsRDD.foreach(println)
    //    println("="*100)
    //    studentsRDD.foreach(println)

    //    while (true){
    //
    //    }

    /**
     *  collect()行动算子 主要作用是将RDD转成scala中的数据结构
     *
     */
    val tuples: Array[(String, String, String, String, String)] = studentsRDD.collect()

  }

}
相关推荐
SafePloy安策42 分钟前
ES信息防泄漏:策略与实践
大数据·elasticsearch·开源
学术搬运工1 小时前
【珠海科技学院主办,暨南大学协办 | IEEE出版 | EI检索稳定 】2024年健康大数据与智能医疗国际会议(ICHIH 2024)
大数据·图像处理·人工智能·科技·机器学习·自然语言处理
星染xr1 小时前
kafka 生产经验——数据积压(消费者如何提高吞吐量)
分布式·kafka
东方巴黎~Sunsiny1 小时前
如何监控Kafka消费者的性能指标?
分布式·kafka
飞升不如收破烂~1 小时前
kafka
分布式·kafka
Matrix702 小时前
HBase理论_背景特点及数据单元及与Hive对比
大数据·数据库·hbase
龙哥·三年风水3 小时前
群控系统服务端开发模式-应用开发-前端个人信息功能
分布式·vue·群控系统
B站计算机毕业设计超人3 小时前
计算机毕业设计Python+大模型农产品价格预测 ARIMA自回归模型 农产品可视化 农产品爬虫 机器学习 深度学习 大数据毕业设计 Django Flask
大数据·爬虫·python·深度学习·机器学习·课程设计·数据可视化
Carl_奕然4 小时前
【大数据算法】MapReduce算法概述之:MapReduce基础模型
大数据·算法·mapreduce
小码哥呀4 小时前
RabbitMQ集群搭建
分布式·rabbitmq