分类导航

程序笔记发布时间：2022-07-04 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了Sparkcore学习（二），大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

RDD创建

根据本地创建

parallelize

读取文件创建

根据读取文件创建RDD
- spark读取文件的方式:
  1. 如果集群配置文件中有配置
    1. HADOOP_CONF_DIR配置,此时默认读取是HDFS文件【公司一般有配置HADOOP_CONF_DIR】
      1. 读取HDFS文件
        
        sc.textFile("/../...") [默认情况]
        
        sc.textFile("hdfs:///../...")
        
        sc.textFile("hdfs://namenode ip:端口/../..")
      2. 读取本地文件： sc.textFile("file:///../..")
  2. 如果集群配置文件中没有配置HADOOP_CONF_DIR配置,此时默认读取是本地文件
    1. 读取HDFS文件
      1. sc.textFile("hdfs://namenode ip:端口/../..")
    2. 读取本地文件：
      1. sc.textFile("file:///../..")
      2. sc.textFile("/../...") [默认情况]

其他rdd衍生

通过其他RDD（计算逻辑）推导出的

拓展

-–master yarn 状态下读取本地文件时报错，时因为任务是集群上运行的，可能在某台机器上可以读取到文件，而有些机器没法督导文件，因此报错。

RDD分区数

通过集合创建的RDD分区数

parallelize方法numSlices参数有设置, 分区数 = numSlices的值
parallelize方法numSlices参数没有设置, 分区数 = defaultParallelism
- defaultParallelism的值@R_70_6962@:
  1. 有配置spark.default.parallelism参数,分区数 = spark.default.parallelism参数值
  2. 没有配置spark.default.parallelism参数,

根据文件创建的RDD的分区数,

分区数大于等于MinPartitions

分区数最终是多少个由文件的切片决定。

通过其他RDD衍生的RDD

根据其他rdd衍生出新RDD的分区数 = 依赖的第一个rdd的分区数，即和父RDD一致

算子

spark rdd算子分为两大类:
1. 转换算子[Transformation]: 不会触发任务的计算,只是封装数据的计算过程,转换算子的结果类型是RDD
2. 行动算子[Action]: 会触发任务的计算,行动算子的结果不是RDD类型

Transformation转换算子

value类型

@H_234_130@map* * * *

语法：map(func: RDD元素类型=> B ): 一对一映射
- spark map算子是针对每个分区并行计算
- 总的来讲和Scala中类似

@H_234_130@mapPartitions* * * *

语法：mapPartitions(func: Iterator[RDD元素类型]=>Iterator[B]): 一对一映射[ 一个分区经过mapPartitions里面的函数计算之后返回一个新的分区 ]

@H_234_130@map与mapPartitions的区别:

函数的参数针对的对象不一样
函数返回值不一样
内存回收的时机不一样

@H_234_130@mapPartitionsWithIndex* * * * * * * *

语法：mapPartitionsWithIndex( func: ( Int, Iterator[RDD元素类型] ) => Iterator[B] )

flatmap* * * *

语法：flatMap(func: RDD元素类型=>集合 ) = map + flatten
- flatMap里面的函数是针对RDD每个元素操作,元素有多少个,函数就调用多少次
- flatMap的应用场景: 一对多[一个元素返回一个或者多个结果]

glom

glom: 将每个分区所有数据用数组封装起来
- glom生成的新的RDD的元素类型是ArraY[原RDD元素类型]
- glom生成的新的RDD的元素个数 = 原RDD分区数

groupby* * * *

groupBy(func: RDD元素类型=>K): 按照指定字段分组
- groupBy里面的函数是针对RDD每个元素操作
- groupBy后续是按照函数的返回值进行分组
- groupBy生成的新的RDD中的元素类型是KV键值对
  - K: 就是函数的返回值
  - V：是K在原RDD中对应的所有元素的集合
- groupBy会产生shuffle操作
- spark shuffle阶段: 写入缓冲区[分组 [排序] ] -> [combiner] ->溢写 -> 合并小文件 -> 分区拉取数据 -> 归并[排序]
复习拓展：

filter* * * *

语法filter(func: RDD元素类型=>Boolean ): 按照指定条件过滤
- filter中的函数是针对RDD每个元素操作,元素有多少个,函数就调用多少次
- filter保留的是函数返回值为true的数据

sample* * * * * * * *

sample(with@R_197_9363@cement,fraction[,seed]): 采样
- with@R_197_9363@cement: 同一个元素是否可以被多次采样 <工作中一般设置为false>
- fraction
  - with@R_197_9363@cement=false, fraction代表每个元素被采样的概率[0,1] <工作中一般设置为0.1-0.2左右>
  - with@R_197_9363@cement=true, fraction代表每个元素期望被采样的次数[>0]
应用场景：sample在工作中一般只用于数据倾斜场景。通过采样的数据映射整个数据集的情况出现数据倾斜之后,一般先通过sample采样数据,再统计采样数据中每个key的个数从而得知哪个key出现了数据倾斜（后续采样之后可以通过countByKey这个action算子统计采样结果集中每个key出现了多少次,从而判断哪个key出现了数据倾斜）

disTinct* * * *

disTinct会产生shuffle操作
数据分布在不同块上，需要进行shuffle过程
- 需要将相同数据聚到一个分区中才能进行去重，不然会导致结果不准确

coalesce* * * *

coalesce: 合并分区
- coalesce: 默认只能合并分区,此时不会产生shuffle操作
- 如果想要增大分区数,此时需要设置coalesce的shuffle参数=true,此时会使用shuffle重分区
- 如果后续想要减少分区数,此时推荐使用COalesce,可以避免shuffle操作。

repartition* * * *

repartition: 重分区
- repartition默认既可以增大分区也可以减少分区,都会产生shuffle,底层就是使用的coalesce(分区数,shuffle=truE).
- 如果想要增大分区,推荐使用repartition,使用简单

repartition与coalesce的区别:

coalesce默认只能合并分区,此时不会产生shuffle操作，如果想要增大分区数,此时需要设置coalesce的shuffle参数=true,此时会使用shuffle重分区 <如果想要减少分区推荐使用COalesce,一般是搭配filter使用,可以避免shuffle>
repartition默认既可以增大分区也可以减少分区,但是都会产生shuffle <如果想要增大分区推荐使用repartition,因为更简单> t

sortBy* * * *

语法sortBy(func: RDD元素类型=> K ): 按照指定字段排序
- sortBy里面的函数是针对RDD单个元素操作
- sortBy是根据函数的返回值进行排序
- sortBy默认是升序,如果想要降序将ascding参数设置为false既可以
sortBy会产生shuffle操作，是全局排序

pipe

pipe: 调用脚本
- pipe是每个分区调用一次脚本
- pipe后续会将一个分区所有数据传递给脚本作为参数
- pipe会生成新的RDD,新RDD的元素是在脚本中通过echo返回的

双value类型交互

intersection交集

函数签名：def intersection(other: RDD[T]): RDD[T]

//使用
val rdd1 = sc.parallelize(List(1,2,3,4,5))
val rdd2 = sc.parallelize(List(4,5,6,7,8))
val rdd3 = rdd1.intersection(rdd2)

会产生shuffle过程，且产生两次

union并集

函数签名：def union(other: RDD[T]): RDD[T]

//使用
val rdd1 = sc.parallelize(List(1,2,3,4,5))
val rdd2 = sc.parallelize(List(4,5,6,7,8))
val rdd3 = rdd1.union(rdd2)

不会产生shuffle，合并后的分区数等于两个父RDD分区数之和

subtract差集

函数签名：def subtract(other: RDD[T]): RDD[T]

//使用
val rdd1 = sc.parallelize(List(1,2,3,4,5))
val rdd2 = sc.parallelize(List(4,5,6,7,8))
val rdd3 = rdd1.subtract(rdd2)

会产生shuffle过程，且产生两次

zip拉链

函数签名：def zip[U: ClassTag](other: RDD[U]): RDD[(T, U)]

两个RDD要想拉链必须元素个数与分区数都相同

val rdd = sc.parallelize(List("lisi","wangwu","zhoaliu"),2)
val rdd2 = sc.parallelize(List(20,30,40),2)
val rdd3 = rdd.zip(rdd2)

Key-Value类型

partitionBy()按照K重新分区

函数签名：def partitionBy(partitioner: Partitioner): RDD[(K, V)]
partitionBy: 根据指定的分区器重分区
将RDD[K,V]中的K按照指定Partitioner重新进行分区；
如果原有的RDD和新的RDD是一致的话就不进行分区，否则会产生Shuffle过程。

自定义分区

要实现自定义分区器，需要继承org.apache.spark.Partitioner抽象类，并实现下面三个方法。
1. numPartitions: Int:返回创建出来的分区数。
2. getPartition(key: Any): Int:返回给定键的分区编号（0到numPartitions-1）。
3. equals():Java 判断相等性的标准方法。这个方法的实现非常重要，Spark需要用这个方法来检查你的分区器对象是否和其他分区器实例相同，这样Spark才可以判断两个RDD的分区方式是否相同

groupByKey()按照K重新分组

函数签名：def groupByKey(): RDD[(K, Iterable[V])]
groupByKey: 根据key分组
- groupBykey生成的新RDD的元素是[K,V]键值对
  - K: 是分组的K
  - V：是K在原RDD中对应的所有的value值的集合

val rdd = sc.parallelize(List( ("aa",10) ,("cc",20),("aa",100),("dd",40),("cc",300)  ))
val rdd2 = rdd.groupByKey()
//结果
List((aa,CompactBuffer(10, 100)), (dd,CompactBuffer(40)), (cc,CompactBuffer(20, 300)))

reduceByKey()按照K聚合V* * * *

语法：reduceByKey(func: (value值类型, value值类型)=>value值类型 ): 按照key分组之后,对每个组所有的value值聚合
reduceByKey在combiner阶段针对每个组所有的value值第一次聚合的时候,函数的第一个参数的初始值 = 第一个value值
reduceByKey的combiner阶段与reducer阶段的聚合逻辑是完全一样,逻辑就是传入的func函数
- groupByKey与reduceByKey的区别:
  - groupByKey: 只是单纯分组, shuffle过程中没有预聚合功能, shuffle效率比较低
  - reduceByKey: 分组+聚合, shuffle过程中有预聚合功能, shuffle效率更高
- 工作中尽量使用高性能的shuffle算子

combineByKey()转换结构后分区内和分区间操作

函数签名： def combineByKeY[C] (createCombiner: V => C, mergeValue: (C, V) => C,mergeCombiners: (C, C) => C): RDD[(K, C)]
combineByKey(createCombiner: RDDvalue值类型 => C,mergeValue: (C, RDDvalue值类型) => C,mergeCombiners: (C, C) => C)
- createCombiner: 在combiner阶段对每个组第一个value值进行转换

foldByKey()分区内

foldByKey(默认值)(func: (value值类型,value值类型)=>value值类型) ：按照key分组,对每个组所有value值聚合
foldByKey在combiner阶段针对每个组第一次计算的时候, 函数第一个参数的初始值 = 默认值

aggregateByKey()分区间相同的

aggregateByKey(默认值)(seqOp,combOp)
- seqOp: combiner聚合函数
  - combiner阶段针对每个组第一个计算的时候, seqOp函数的第一个参数的初始值 = 默认值
- combOp: reducer聚合函数

combineByKey()转换结构后分区内和分区间操作

函数签名：def combineByKeY[C] (createCombiner: V => C,mergeValue: (C, V) => C,mergeCombiners: (C, C) => C): RDD[(K, C)]

reduceByKey、foldByKey、aggregateByKey、combineByKey的区别

reduceBykey:

combineByKeyWithClassTag[V] ((v: V) => v, func, func, partitioner) 第一个初始值不变

combineByKey: combineByKeyWithClassTag(createCombiner, mergeValue, mergeCombiners)(null) 分区内和分区间规则一致
foldByKey: combineByKeyWithClassTag[V] ((v: V) => cleanedFunc(默认值, v),cleanedFunc, cleanedFunc, partitioner) 第一个初始值和分区内处理规则一致
aggregateBykey: combineByKeyWithClassTag[U] ((v: V) => cleanedSeqOp(默认值, v),cleanedSeqOp, combOp, partitioner) 把第一个值变成特定的结构

reduceByKey、foldByKey、combineByKey、aggregateByKey区别:
- reduceByKey: 在combiner阶段对每个组所有value值第一次计算的时候,函数的第一个参数的初始值 = 该组第一个value值, combiner与reducer计算逻辑完全一样
- foldByKey: 在combiner阶段对每个组所有value值第一次计算的时候,函数的第一个参数的初始值 = 默认值, combiner与reducer计算逻辑完全一样
- combinerByKey: 在combiner阶段对每个组所有value值第一次计算的时候,函数的第一个参数的初始值 = 第一个函数的转换结果
- aggregateByKey: 在combiner阶段对每个组所有value值第一次计算的时候,函数的第一个参数的初始值 = 默认值

sortByKey()按照K进行排序

函数签名：

def sortByKey(ascending: Boolean = true, numPartitions: Int =elf.partitions.length)  : RDD[(K, V)]// 默认，升序

sortByKey: 根据key排序
在一个(K,V)的RDD上调用，K必须实现ordered接口，返回一个按照key进行排序的(K,V)的RDD
可以通过sortBy完成sortByKey操作

@H_234_130@mapValues()只对V进行操作

Join连接

join: 两个rdd只有key相同的才能连接,join生成的RDD的元素类型是 (key,(左rdd value值,右rdd value值)) 【类似sql inner join】
leftOuterJoin: 两个rdd key相同的能连接+ 左rdd不能连接的数据,join生成的RDD的元素类型是 (key,(左rdd value值,Option(右rdd value值)))
rightOuterJoin: 两个rdd key相同的能连接+ 右rdd不能连接的数据,join生成的RDD的元素类型是 (key,(Option(左rdd value值),右rdd value值))
fullOuterJoin: 两个rdd key相同的能连接+ 右rdd不能连接的数据+左rdd不能连接的数据,join生成的RDD的元素类型是 (key,(Option(左rdd value值),Option(右rdd value值)))

cogroup()类似全连接

类似先对两个rdd实现groupByKey ，然后针对两个rdd 的分组结果执行全外连接

Action行动算子

reduce()聚合* * * * * *

函数签名：def reduce(f: (T, T) => T) : T
reduce是对rdd所有元素聚合
reduce是先对每个分区所有数据聚合,将每个分区的聚合结果发给Driver,由Driver统一汇总

collect()以数组的形式返回数据集

函数签名：def collect(): ArraY[T]
将rdd每个分区的数据收集到Driver端口
特别提醒：所有的数据都会被拉取到Driver端，慎用
- 如果rdd分区数据量比较大,而Driver内存默认只有1G,所以可能出现内存溢出
- 在工作中一般都需要调整Driver的内存大小,一般调整为5-10G.
- 在spark-submit的是可以通过--driver-memory调整Driver内存大小

count()返回RDD中元素个数

函数签名：def count(): Long
返回RDD中元素的个数

first()返回RDD中的第一个元素

函数签名：def first(): T
返回RDD中的第一个元素

take()返回由RDD前n个元素组成的数组

def take(num: int): ArraY[T]
返回一个由RDD的前n个元素组成的数组

takeordered()返回该RDD排序后前n个元素组成的数组

函数签名：def takeordered(num:int) (implicit ord: Ordering[T]): ArraY[T]
返回该RDD排序后的前n个元素组成的数组
猜测会产生shuffle过程

fold()

函数签名：def fold(zeroValue: T) (op: [T , T]): T
fold(默认值)(func: (RDD元素类型,RDD元素类型)=> RDD元素类型): 对RDD所有元素聚合
- fold首先会对每个分区所有元素中进行聚合,然后将每个分区的聚合结果发给Driver进行汇总
  - fold在每个分区中第一次计算的时候,函数第一个参数的初始值 = 默认值
  - fold在Driver第一次计算的时候,函数第一个参数的初始值 = 默认值

aggregate()

函数签名：def aggregate(U: ClassTag) (zeroValue: U) (seqOp: (U , T): U,combOp:(U : U)=>U):U
aggregate(默认值)(seqOp: (默认值类型,RDD元素类型)=> 默认值类型 , comop: ( 默认值类型,默认值类型 )=>默认值类型 ) : 对RDD所有元素聚合
- seqOp: 是在每个分区中对所有元素聚合逻辑
- comop：在driver中对所有分区的聚合结果的汇总逻辑

fold与aggregate的区别:

fold的分区内聚合逻辑与driver汇总逻辑一样
aggregate的分区内聚合逻辑与driver汇总逻辑可以不一样

countByKey()统计每种key的个数* * * * * *

函数签名：def countByKey(): Map[K, Long]
countByKey一般结合sample一起使用
- 后续如果出现了数据倾斜,一般先用sample采样数据,然后用countByKey统计采样结果,从而得知哪个key出现了数据倾斜

save相关算子

saveAsTextFile(path)保存成Text文件

将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本

saveAsSequenceFile(path)保存成Sequencefile文件

将数据集中的元素以Hadoop Sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
注意：只有kv类型RDD有该操作，单值的没有

saveAsObjectFile(path) 序列化成对象保存到文件

用于将RDD中的元素序列化成对象，存储到文件中。

foreach(f)遍历RDD中每一个元素

函数签名：def foreach(f:T=>Unit): Unit
遍历RDD中每一个元素
foreach(func: RDD元素类型=>Unit): Unit
- foreach里面的函数是针对单个元素操作,元素有多少个,函数就调用多少次,没有返回值
- foreach是并行执行
- foreach与map的区别:
  - foreach是行动算子,不会生成新的RDD,会触发任务计算,得到具体的结果

foreachPartition()* * * * * *

foreachPartition(func: Iterator[RDD元素类型]=>Unit):Unit
- foreachPartition里面的函数是针对每个分区操作,函数的参数是每个分区所有数据的迭代器,rdd有多少分区,函数就执行多少次。
- foreachPartition一般用于将数据保存到mysql,hbase,redis等存储介质中,可以减少资源链接的创建与销毁的次数。

序列化

闭包

函数体中使用了外部变量的函数称之为闭包.

spark序列化原因：

spark算子里面的函数是在executor中的task执行的,spark算子外面的代码是在driver执行的,如果spark算子里面的函数体中使用了dirver定义的变量
此时spark会将该driver变量序列化之后传给task使用,所以就必须要求该driver变量类型必须能够序列化才行。

spark里面的有两种序列化: java序列化[默认使用],kryo序列化

java序列化: 在序列化对象的时候会将对象的全类名、属性、属性类型、继承信息等全部都会序列化进去
kryo序列化: 只会序列化类名、属性名、属性值、属性类型信息[序列化性能比java序列化高10倍左右]
在实际工作中一般选择使用kryo序列化

如何配置spark使用kryo序列化:

在sparkconf中配置spark默认使用的序列化器: new SparkConf().set("spark.serializer","org.apache.spark.serializer.Kryoserializer")
注册哪些类使用kryo序列化【可选】: new SparkConf().registerKryoClasses(Array(classOf[待序列化的类的类名])
- 使用registerKryoClasses与不使用egisterKryoClasses的区别:
  1. 使用registerKryoClasses，此时再序列化类的时候不会将类的全类名序列化进去
  2. 没有使用registerKryoClasses，此时在序列化类的时候会将类的全类名序列化进去

RDD依赖关系

查看血缘关系

一个job中多个rdd之间的关系
rdd的血统可以通过toDebugString查看

查看依赖关系

要想理解RDDS是如何工作的，最重要的就是理解Transformations。

RDD之间的关系可以从两个维度来理解：一个是RDD是从哪些RDD转换而来，也就是 RDD的parent RDD(s)是什么; 另一个就是RDD依赖于parent RDD(s)的哪些Partition(s)，这种关系就是RDD之间的依赖。

窄依赖

窄依赖表示每一个父RDD的Partition最多被子RDD的一个Partition使用，最简单的理解就是是否有shuffle过程，没有就是窄依赖。

宽依赖

宽依赖表示同一个父RDD的Partition被多个子RDD的Partition依赖，会引起Shuffle
具有宽依赖的transformations包括：sort、reduceByKey、groupByKey、join和调用rePartition函数的任何操作。
宽依赖对Spark去评估一个transformations有更加重要的影响，比如对性能的影响。

Stage任务划分

stage切分: 根据最后一个rdd的依赖关系向前找父RDD，然后根据父RDD的依赖关系继续向前,依次查找,一直找到第一个RDD位置。在中间查询的过程中如果父子依赖关系是宽依赖则切分stage.
stage的执行: 一个job中的stage是从前往后执行,先执行第一个stage，在执行后面的stage
Application: 应用, 一个sparkcontext称之为一个应用。
- job: 任务, 一般一个action算子产生一个Job [first与take除外，这两个可能产生多个Job]
  - stage: 阶段, job中stage的个数 = shuffle个数+1
  - task: 子任务, 一个stage中task的个数 = stage中最后一个rdd的分区数
一个job中多个stage的执行是串行
一个stage中多个task的执行是并行

RDD任务切分中间分为：Application、Job、Stage和Task
1. Application：初始化一个SparkContext即生成一个Application；
2. Job：一个Action算子就会生成一个Job；
3. Stage：Stage等于宽依赖的个数加1；
4. Task：一个Stage阶段中，最后一个RDD的分区个数就是Task的个数。
  - 注意：Application->Job->Stage->Task每一层都是1对n的关系。

RDD持久化

RDD Cache缓存

RDD的持久化过程：RDD通过Cache或者Persist方法将前面的计算结果缓存，默认情况下会把数据以序列化的形式缓存在JVM的堆内存中。但是并不是这两个方法被调用时立即缓存，而是触发后面的action时，该RDD将会被缓存在计算节点的内存中，并供后面重用。
RDD持久化原因: RDD中不存储数据,如果一个rdd在多个job中重复使用,此时默认会重复执行该RDD之前的步骤,如果能将rdd的数据保存下来，后续job就不用重复执行该rdd之前的步骤了。
应用场景:
1. 一个rdd在多个job中重复使用
2. job中依赖链条太长,可以避免计算出错导致重新计算

如何持久化

缓存: 将RDD的数据保存到分区所在机器的内存/磁盘中 <常用>
- 使用方式:
  - rdd.cache/ rdd.persist(参数…..)
- cache与persist的区别:
  1. cache是数据只能保存到内存中
  2. persist可以指定将数据保存到内存/磁盘中
- 常用的存储级别(persist的参数):
@R_696_10943@kpoint: 将RDD的数据保存到HDFS中
- 原因: 缓存是将数据保存到本机的内存/磁盘中,如果服务器宕机，数据丢失，spark会重写启动一个task,然后根据rdd依赖关系重新计算得到数据, 影响效率。
- 如何使用: rdd.@R_696_10943@kpoint
  - 每个job执行完成之后,spark会查看当前job中是否有rdd需要@R_696_10943@kpoint，如果有则将该rdd之前的数据处理步骤再次执行得到数据之后保存到指定@R_696_10943@kpoint路径。所以@R_696_10943@kpoint会触发一次job操作。
  - 所以如果想要避免@R_696_10943@kpoint之前的处理重复执行可以将@R_696_10943@kpoint操作与cache结合使用: rdd.cache ; rdd.@R_696_10943@kpoint()

缓存与@R_696_10943@kpoint的区别:

数据保存位置不一样:
- 缓存是将RDD的数据保存到分区所在机器的内存/本地磁盘中
- @R_696_10943@kpoint是将RDD的数据保存到HDFS中
依赖关系是否保留不一样
- 缓存是将RDD的数据保存到分区所在机器的内存/本地磁盘中,如果服务器宕机,数据丢失之后需要根据依赖关系重新计算得到数据,所以RDD的依赖关系必须保留
- @R_696_10943@kpoint是将RDD的数据保存到HDFS中，数据不会丢失,所以RDD的依赖关系会删除

键值对RDD数据分区

分区器: 用于shuffle阶段

spark自带的分区器:
- HashPartitioner:
  - 分区规则: key.hashCode % 分区数 < 0 ? key.hashCode % 分区数 + 分区数 : key.hashCode % 分区数
- RangePartitioner:
  - 分区规则: 会采用采样的方式从数据集中抽取分区数-1 个key,
  - 通过这几个采样的key确定每个分区的边界，
  - 后续将key与分区边界对比如果在边界范围内则放入对应分区中。

注意：
1. 只有Key-Value类型的RDD才有分区器，非Key-Value类型的RDD分区的值是None
2. 每个RDD的分区ID范围：0~numPartitions-1，决定这个值是属于那个分区的。

转换算子和行动算子中带 * 号的相对重要

大佬总结

以上是大佬教程为你收集整理的Sparkcore学习（二）全部内容，希望文章能够帮你解决Sparkcore学习（二）所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：agg bug hdfs list map master mysql partition php redis shuffle spark sql 参数大数据序列化应用场景排序查找程序员资源遍历

上一篇: dfs和bfs解决岛屿问题下一篇:Abp Vnext Vue3 的版本实现

猜你在找的程序笔记相关文章

You can't specify target table 'xxx' for update in FROM clause的解决 2022-07-21
【UNIAPP】上传视频，进度条的前台与后端 2022-07-21
十款代码表白特效，一个比一个浪漫！ 2022-07-04
作业3 2022-07-06
linux系统下部署项目访问报404错误的解决方法 2022-05-30
C++带有指针成员的类处理方式详解 2022-06-07
Linux——（1）基本命令 2022-07-21
JavaScript之正则表达式学习笔记 2019-11-07
Redux源码学习笔记 2019-11-07
Webpack学习笔记 2019-11-07