spark04--算子总结,RDD类型,宽窄依赖,学科访问量统计,缓存,自定义分区,DAG,stage,执行任务时对象创建和序列化

最新推荐文章于 2023-04-28 15:46:40 发布
最新推荐文章于 2023-04-28 15:46:40 发布
阅读量545 收藏 1
点赞数
分类专栏： spark 文章标签： 依赖关系 缓存 自定义分区 DAG stage
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/forever428/article/details/85757353
版权

文章目录

一 算子总结

1.1 map和mapPartitions的区别

map是处理RDD里的每个元素, mapPartitions是用于处理RDD里的每个分区

1.2 map和foreach的区别:
  1. map有返回值, foreach没有返回值
  2. map常用于将某个RDD做元素的处理, 而foreach常用于作为结果的输出到其他的存储系统中
  3. map是transformation算子, 而foreach是属于action算子
1.3 foreach和foreachPartition的区别:
  1. foreach是针对RDD的每个元素来操作的, foreachPartition是针对RDD的每个分区进行操作的
  2. 从优化层面讲: foreachPartition常用于存储大量结果数据的场景, 可以一个分区对应一个数据库的连接, 这样就可以减少很多数据库的连接
    rdd.foreachPartition(part =>{
	//val conn = ... //获取一个数据库的连接
	part.foreach(操作元素) //遍历每一个元素进行操作
})

二 RDD类型

在这里插入图片描述

直接打印RDD类型

System.out.println(res.toDebugString());

在这里插入图片描述

三 RDD依赖关系

RDD和它依赖的父RDD（s）的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。
在这里插入图片描述

3.1 窄依赖

窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用
总结：窄依赖我们形象的比喻为独生子女

3.2 宽依赖

宽依赖指的是多个子RDD的Partition会依赖同一个父RDD的Partition
总结：宽依赖我们形象的比喻为超生

3.3 join有时宽依赖有时窄依赖

  1. 如果在join之前进行了groupBy的操作, join的过程就不会发生shuffle, 也就是窄依赖
    在这里插入图片描述

  2. 如果join操作之前没有groupBy等操作, 直接进行join操作一般都会发生shuffle, 这个地方在实操中可以做一个优化
    在这里插入图片描述

3.4 宽窄依赖区分

  1. 既有宽依赖又有窄依赖
    在这里插入图片描述

  2. 前后分区不一致
    在这里插入图片描述

四 案例一:学科访问量统计_1

4.1 数据

在这里插入图片描述

4.2 需求
  • 求各个学科各个模块的访问量
4.3 实现思路
  1. 计算出每个学科各个模块(url)的访问量
  2. 按照学科进行分组
  3. 组内排序, 取top(n)
4.4 实现代码
import java.net.URL

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

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

    // 获取数据
    val logs: RDD[String] = sc.textFile("G:\\06-Spark\\sparkcoursesinfo\\spark\\data\\subjectaccess\\access.txt")

    // 将用户访问日志进行切分并返回URL
    val url: RDD[String] = logs.map(line => line.split("\t")(1))

    // 将URL生成元组, 便于聚合
    val tupUrl: RDD[(String, Int)] = url.map((_, 1))

    // 获取每个学科的各个模块的访问量
    val reducedUrl: RDD[(String, Int)] = tupUrl.reduceByKey(_ + _)

    // 通过上面的数据来获取学科信息
    val subjectAndUrlInfo: RDD[(String, (String, Int))] = reducedUrl.map(tup => {
      val url: String = tup._1 // 用户请求的url
      val count: Int = tup._2 // url对应的pv
      val subject: String = new URL(url).getHost
      (subject, (url, count))
    })
    //println(subjectAndUrlInfo.collect.toBuffer)

    // 按照学科进行分组
    val grouped: RDD[(String, Iterable[(String, Int)])] = subjectAndUrlInfo.groupByKey

    // 组内进行降序排序
    val sorted: RDD[(String, List[(String, Int)])] = grouped.mapValues(_.toList.sortBy(_._2).reverse)

    //获取top3
    val res: RDD[(String, List[(String, Int)])] = sorted.mapValues(_.take(3))

    println(res.collect.toBuffer)

    sc.stop()
  }
}
4.5 运行结果

在这里插入图片描述

五 案例二: 学科访问量统计_2(缓存)

5.1 解读缓存源码

缓存有两个方法cache和persist, 通过源码可以看出cache调用了persist, 所以这两个方法运行的效率可以看做是一样的
在这里插入图片描述
在persist方法中需要传入StorageLevel这个对象
在这里插入图片描述

StorageLevel对象中可以指定缓存的数据存入到内存中, 磁盘中, 堆外缓存中, 是否关闭序列化, 以及副本数量
在这里插入图片描述

StorageLevel有一个伴生类, 在这个伴生类中给定了一些常量(层级划分), 其中有两个比较常用的, 一个是仅内存(MEMORY_ONLY), 另一个是磁盘和内存(MEMORY_AND_DISK). 这里强调一下, MEMORY_AND_DISK并不是在内存和磁盘中各存一份, 而是优先存储到内存中, 当内存不足时, 缓存的数据会存储到磁盘中.
在这里插入图片描述

5.2 使用缓存
import java.net.URL

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

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

    // 获取数据
    val logs: RDD[String] = sc.textFile("G:\\06-Spark\\sparkcoursesinfo\\spark\\data\\subjectaccess\\access.txt")

    // 学科信息
    val subjects = Array("http://java.learn.com", "http://ui.learn.com", "http://bigdata.learn.com", "http://android.learn.com", "http://h5.learn.com")

    // 将用户访问日志进行切分并返回URL
    val url: RDD[String] = logs.map(line => line.split("\t")(1))

    // 将URL生成元组, 便于聚合
    val tupUrl: RDD[(String, Int)] = url.map((_, 1))

    // 获取每个学科的各个模块的访问量
    // 注意: 在cache的时候需要考虑的是cache的数据量不能太大, 否则缓存数据太大会影响效率
    //       这个缓存的数据量需要根据节点的实际情况来判断
    val reducedUrl: RDD[(String, Int)] = tupUrl.reduceByKey(_ + _).cache()

    // 用for循环对学科和数据进行匹配
    for (subject <- subjects) {
      val filteredSubject: RDD[(String, Int)] = reducedUrl.filter(_._1.startsWith(subject))
      val res: Array[(String, Int)] = filteredSubject.sortBy(_._2, false).take(3)
      println(res.toBuffer)
    }
    sc.stop()
  }
}
5.3 运行结果

在这里插入图片描述

六 案例三: 学科访问量统计_3(自定义分区器)

6.1 实现自定义分区按照不同的学科信息将数据进行分区
import java.net.URL

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

import scala.collection.mutable

/**
  * 实现自定义分区, 按照不同的学科信息将数据进行分区
  */
object SubjectAccessCount_3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("SubjectAccessCount")
    val sc = new SparkContext(conf)

    // 获取数据
    val logs: RDD[String] = sc.textFile("G:\\06-Spark\\sparkcoursesinfo\\spark\\data\\subjectaccess\\access.txt")

    // 学科信息
    //    val subjects = Array("http://java.learn.com", "http://ui.learn.com", "http://bigdata.learn.com", "http://android.learn.com", "http://h5.learn.com")

    // 将用户访问日志进行切分并返回URL
    val url: RDD[String] = logs.map(line => line.split("\t")(1))

    // 将URL生成元组, 便于聚合
    val tupUrl: RDD[(String, Int)] = url.map((_, 1))

    // 获取每个学科的各个模块的访问量
    // 注意: 在cache的时候需要考虑的是cache的数据量不能太大, 否则缓存数据太大会影响效率
    //       这个缓存的数据量需要根据节点的实际情况来判断
    val reducedUrl: RDD[(String, Int)] = tupUrl.reduceByKey(_ + _).cache()

    val subjectInfo: RDD[(String, (String, Int))] = reducedUrl.map(tup => {
      val url: String = tup._1
      val count: Int = tup._2
      val subject: String = new URL(url).getHost
      (subject, (url, count))
    }).cache()

    // 出现数据倾斜
    //    val partitioned: RDD[(String, (String, Int))] = subjectInfo.partitionBy(new HashPartitioner(3))
    //    partitioned.saveAsTextFile("output")

    // 获取学科信息
    val subjects: Array[String] = subjectInfo.keys.distinct().collect()

    // 调用自定义分区器
    val partitioner = new SubjectPartitioner(subjects)

    // 开始进行分区
    val partitionered: RDD[(String, (String, Int))] = subjectInfo.partitionBy(partitioner)

    val res: RDD[(String, (String, Int))] = partitionered.mapPartitions(it => {
      it.toList.sortBy(_._2._2).reverse.take(3).iterator
    })
    res.saveAsTextFile("output2'")

    sc.stop()
  }
}

// 自定义分区器
class SubjectPartitioner(subjects: Array[String]) extends Partitioner {
  // 声明一个Map, 用于存储学科对应的分区号
  private val subjectAndPartition = new mutable.HashMap[String, Int]()

  // 将学科存储在集合中
  var i = 0
  for (subject <- subjects) {
    subjectAndPartition += (subject -> i)
    i += 1
  }

  /**
    * 获取分区数
    */
  override def numPartitions: Int = subjects.length

  /**
    * 获取分区号
    * @param key
    * @return
    */
  override def getPartition(key: Any): Int = {
    // 获取分区号, 如果没有放到0号分区
    subjectAndPartition.getOrElse(key.toString, 0)
  }
}
6.2 验证Hash碰撞
package Day04

/*
 * @Description:    验证Hash碰撞
 * ClassName HashTest01
 * @Author:         WCH
 * @CreateDate:     2019/1/4$ 15:01$
 * @Version:        1.0
*/
object HashTest01 {
  def main(args: Array[String]): Unit = {
    val key = "ui.learn.com"
    val numPartitions = 3

    val rawMod: Int = key.hashCode % numPartitions
    val num: Int = rawMod + (if (rawMod < 0) numPartitions else 0)

    println(num)

  }
}

七 DAG

7.1 DAG概念

DAG(Directed Acyclic Graph)叫做有向无环图，原始的RDD通过一系列的转换就就形成了DAG，根据RDD之间的依赖关系的不同将DAG划分成不同的Stage，对于窄依赖，partition的转换处理在Stage中完成计算。对于宽依赖，由于有Shuffle的存在，只能在parent RDD处理完成后，才能开始接下来的计算，因此宽依赖是划分Stage的依据。划分stage的目的是为了生成Task.

7.2 DAG划分过程

利用递归算法, 从finalRDD开始找父RDD, 判断他们之间的依赖关系如果是宽依赖, 就划分为一个stage, 就把前面所有的RDD和当前的RDD划分为一个stage, 如果是窄依赖, 就继续找它的父RDD, 直到找不到父RDD, 该递归退出, 最后把所有的RDD划分为一个stage

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  1. RDD的生成: 通过RDD的生成阶段形成了一系列的依赖关系, 发送给DAGScheduler
  2. stage划分过程:调用DAGScheduler对象进行划分, 通过TaskSet发送
  3. task的生成: TaskScheduler会生成一个个task并发送任务到集群
  4. task的提交: 多个worker端中的Executor接收一个个的task进行处理
  • RDD的生成在Driver端发生的
  • stage划分在Driver端发生的
  • task的生成在Driver端发生的
  • task的提交在Driver端发生的
  • task的执行时在Executor端发生的

在这里插入图片描述

八 执行任务时创建对象和序列化

有如下规则, 现在需要在算子中使用规则

class Rules extends Serializable {
  val rulesMap = Map("xiaoli" -> 25, "xiaofang" -> 27)
}
8.1 将创建对象放到算子中

将创建对象放到算子中, 这个时候无需实现序列化, 因为每一个节点中的每一个线程中遍历每一个元素的时候都会创建一个对象, 通过打印对象的地址可以观察到每个地址都是不同的, 即没有发生磁盘IO, 所以无需实现序列化

import java.net.InetAddress
import org.apache.spark.{SparkConf, SparkContext}

/**
  * 一条数据创建一次对象, 效率及其低下，不建议在算子内创建对象
  */
object SerializeTest_1 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SerTest").setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(Array("xiaoli", "xiaofang", "xiaolin"))

    // map方法中的函数是在Executor的某个Task中执行的
    val res = lines.map(x => {
      // 该对象是在Executor端创建的
      val rules = new Rules
      // 获取task的hostname，也就是判断该task是在哪个节点执行的
      val hostname = InetAddress.getLocalHost.getHostName
      // 获取当前线程名称
      val threadName = Thread.currentThread().getName
      //rules是在Executor中使用的
      (hostname, threadName, rules.rulesMap.getOrElse(x, 0), rules.toString)
    })

    println(res.collect.toBuffer)

    sc.stop()
  }
}
8.2 将创建对象放到算子外部

当把创建对象的步骤放在算子外部的时候, 每个节点的每个线程会创建一个对象, 在执行任务的时候, Driver端需要将序列化后的对象传给Executor, Executor接收到之后会进行反序列化, 所以这里创建的Rules 对象必须要继承序列化特质

import java.net.InetAddress

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

/**
  * 用序列化的方式
  */
object SerializeTest_2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SerTest").setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(Array("xiaoli", "xiaofang", "xiaolin"))

    // 该对象在Driver端创建
    val rules = new Rules
    println("Driver端的哈希值：" + rules.toString)

    // map方法中的函数是在Executor的某个Task中执行的
    val res = lines.map(x => {
      // 获取task的hostname，也就是判断该task是在哪个节点执行的
      val hostname = InetAddress.getLocalHost.getHostName
      // 获取当前线程名称
      val threadName = Thread.currentThread().getName
      // rules是在Executor中使用的
      (hostname, threadName, rules.rulesMap.getOrElse(x, 0), rules.toString)
    })

    println(res.collect.toBuffer)

    sc.stop()
  }
}
8.3 使用单例模式

使用单例模式, 可以在本地运行时达到全局共享的目的, 这样就多个线程共享一个对象, 对象的地址也是一个

import java.net.InetAddress

/**
  * 第三种方式
  */
//object ObjectRules extends Serializable{
//  val rulesMap = Map("xiaoli" -> 25, "xiaofang" -> 27)
//}

/**
  * 第四种方式
  */
object ObjectRules {
  val rulesMap = Map("xiaoli" -> 25, "xiaofang" -> 27)
  println("hostname的名称为：" + InetAddress.getLocalHost.getHostName)
}
8.3.1 单例继承Serializable特质
import java.net.InetAddress

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

/**
  * 用单例对象的方式
  */
object SerializeTest_3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SerTest").setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(Array("xiaoli", "xiaofang", "xiaolin"))

    // 该对象在Driver端创建
    val rules = ObjectRules
    println("Driver端的哈希值：" + rules.toString)

    // map方法中的函数是在Executor的某个Task中执行的
    val res = lines.map(x => {
      // 获取task的hostname，也就是判断该task是在哪个节点执行的
      val hostname = InetAddress.getLocalHost.getHostName
      // 获取当前线程名称
      val threadName = Thread.currentThread().getName
      // rules是在Executor中使用的
      (hostname, threadName, rules.rulesMap.getOrElse(x, 0), rules.toString)
    })

    println(res.collect.toBuffer)
//    res.saveAsTextFile("hdfs://node01:9000/out-20181128-1")

    sc.stop()
  }
}
8.3.2 单例不继承Serializable特质
import java.net.InetAddress

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

/**
  * 用单例对象的方式
  */
object SerializeTest_3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SerTest").setMaster("local[2]")
    val sc = new SparkContext(conf)

    val lines = sc.parallelize(Array("xiaoli", "xiaofang", "xiaolin"))

    // 该对象在Driver端创建
    val rules = ObjectRules
    println("Driver端的哈希值：" + rules.toString)

    // map方法中的函数是在Executor的某个Task中执行的
    val res = lines.map(x => {
      // 获取task的hostname，也就是判断该task是在哪个节点执行的
      val hostname = InetAddress.getLocalHost.getHostName
      // 获取当前线程名称
      val threadName = Thread.currentThread().getName
      // rules是在Executor中使用的
      (hostname, threadName, rules.rulesMap.getOrElse(x, 0), rules.toString)
    })

    println(res.collect.toBuffer)
//    res.saveAsTextFile("hdfs://node01:9000/out-20181128-1")

    sc.stop()
  }
}
forever428
关注
专栏目录
PySpark | RDD持久化 | 共享变量 | Spark内核调度
liujiesxs的博客
06-26 1272
RDD持久化、共享变量、Spark任务调度
Spark分布式计算和RDD模型研究
西代零零发
11-22 1万+
1背景介绍现今分布式计算框架像MapReduce和Dryad都提供了高层次的原语，使用户不用操心任务分发和错误容忍，非常容易地编写出并行计算程序。然而这些框架都缺乏对分布式内存的抽象和支持，使其在某些应用场景下不够高效和强大。RDD(Resilient Distributed Datasets弹性分布式数据集)模型的产生动机主要来源于两种主流的应用场景：Ø  迭代式算法：迭代式机器学习、图算法，包
Spark RDD宽窄依赖
陈小哥cw
09-02 451
RDD和它依赖的父RDD（s）的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。 1.窄依赖 窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用 总结：窄依赖我们形象的比喻为独生子女 父RDD和子RDD partition之间的关系是一对一的。 父RDD和子RDD partition之间的关系是...
spark中RDD的宽窄依赖和spark计算模式（图解）
wyqwilliam的博客
07-19 466
Spark宽窄依赖详解
热门推荐
modefrog的博客
03-16 2万+
1.宽窄依赖 图中左边是宽依赖，父RDD的4号分区数据划分到子RDD的多个分区（一分区对多分区），这就表明有shuffle过程，父分区数据经过shuffle过程的hash分区器（也可自定义分区器）划分到子RDD。例如GroupByKey，reduceByKey，join，sortByKey等操作。图右边是窄依赖，父RDD的每个分区的数据直接到子RDD的对应一个分区（一分区对一分区），例如1号到5号...
RDD的依赖关系（宽依赖和窄依赖）(学习笔记)
SX的博客
07-13 1545
RDD和它依赖的父RDD（s）的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。 窄依赖 窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用，例如map、filter、union等操作会产生窄依赖。 总结：窄依赖我们形象的比喻为独生子女 宽依赖 宽依赖指的是多个子RDD的Partition会依赖同...
spark的宽窄依赖
weixin_41745141的博客
03-09 589
spark的宽窄依赖
Spark概述与RDD的运用
zhou_zhao_xu的博客
12-02 307
文章目录Apache Spark一、概述特点二、环境搭建Standalone（独立模式）准备工作安装Hadoop安装Spark安装Spark On Yarn准备工作三、开发第一个Spark应用Maven依赖编写WordCount应用项目打包上传Jar包Linux操作系统提交Jar包Standalone集群中运行本地模拟测试开发四、Spark架构MapReduce On Yarn工作原理Spark ...
Spark-概览
qq243774546的博客
07-06 143
文章目录多线程模型异步并发模型作业提交宽/窄依赖任务调度ShuffleRDD持久化 Spark集群分为Master节点和Worker节点，相当于Hadoop的Master和Slave节点。Master节点上常驻Master守护进程，负责管理全部的Worker节点。Worker节点上常驻Worker守护进程，负责与Master节点通信并管理executors。 Driver 官方解释是 The process running the main() function of the application and
Spark高阶编程-如何编写高效代码
lyd882的博客
06-12 841
Spark高阶编程 1.Spark源码解析 ​ 以下以yarn-client提交sparkPI任务流程为例 ​ 执行${SPARK_HOME}/bin/spark-submit 提交任务命令 spark-submit --master yarn --deploy-mode client --executor-cores 1 --num-executors 1 --class org.apache.spark.examples.SparkPi ${SPARK_HOME}/examples/jars/s
Spark RDD特征与宽窄依赖
zhuhailong
09-03 1608
Spark RDD的特征与宽窄依赖
spark rdd之间的宽依赖和窄依赖
u013174239的博客
05-07 534
①task从hdfs读取数据到linesRDD中，同一批task对linesRDD进行flatMap操作；②继续对wordsRDD做map操作，记录单词次数③这个地方会划分一个stage，新的一批task会提交到executor上，对pairs RDD做reduceByKey操作窄依赖（narrow dependency）：每一个父RDD的Partition最多被子RDD的一个Partition使...
详解 Spark RDD 的宽窄依赖关系
weixin_43958974的博客
01-04 3588
前言 上期讲解了 Spark RDD 核心结构及其概念，本期详细讲一讲 Spark RDD 依赖关系的内容。 学习目标 RDD 的依赖关系 如何区分宽窄依赖 为何设计要宽窄依赖 RDD的依赖关系 在 Spark 中，RDD 分区的数据不支持修改，是只读的。如果想更新 RDD 分区中的数据，那么只能对原有 RDD 进行转化操作，也就是在原来 RDD 基础上创建一个新的RDD。 那么，在整个任务的运算过程中，RDD 的每次转换都会生成一个新的 RDD，因此 RDD 们之间会产生前后依赖的关系.
Spark Core 自定义排序、分区
weixin_43969505的博客
08-15 329
自定义排序（重要） spark中对简单的数据类型可以直接排序,但是对于一些复杂的条件以利用自定义排序来实现 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} //自定义排序 object CustomSortTest { def main(args: Array[String]): U...
【Spark练习】宽、窄依赖
最新发布
weixin_40433003的博客
04-28 423
spark算子 reduceByKey和GroupByKey
spark.1 rdd 分区 宽依赖 窄依赖 stage job
笔生花的博客
10-18 987
RDD: rdd是是不可更改的，分区的，可并行执行的分布式数据集。partition是rdd的重要概念也可以说rdd是一组分区数据组成的，而不同的分区可以发送到不同的节点上并行执行，rdd的概念造是数据能够并行执行的基础。 ...
spark-宽窄依赖
DCHAO的博客
10-20 2704
这是rdd论文中的图，可见，宽窄依赖划分的依据并不是是否产生了网络io，而是一个分区的数据是否发生了拆分，注意，是拆分，合并不算
Spark 学习（四）RDD自定义分区和缓存
weixin_30319153的博客
06-07 167
一，简介 二，自定义分区规则 　　2.1普通的分组TopN实现 　　2.2自定义分区规则TopN实现 三，RDD的缓存 　　3.1 RDD缓存简介 　　3.2 RDD缓存方式 正文 一，简介 　　在之前的文章中，我们知道RDD的有一个特征：就是一组分片（Partition），即数据集的基本组成单位。对于RDD来说，每个分片都会被一个计算任务处理，并决定...
spark七 自定义分区
04-02 127
/** * 自定义分区器 */ class SubjectPartitoner(subjects: Array[String]) extends Partitioner{ // 用于存储学科信息以及对应的分区号 val subjectAndNum = new mutable.HashMap[String, Int](); // 计 /数器，用来生成分区号 var i = 0...
Spark-RDD-Scala 算子操作数据源分析
"data01.txt 是一个用于 Spark RDD Scala 算子操作的示例数据文件，包含多行数据，每行数据由四部分组成：姓名、技能领域、在该领域的评分（可能是技能掌握程度）和未知字段。数据涉及多个计算机科学和技术主题，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值