Spark计算平台算子介绍与学习

最新推荐文章于 2024-07-31 15:54:40 发布
最新推荐文章于 2024-07-31 15:54:40 发布
阅读量939 收藏 1
点赞数
分类专栏： spark平台学习

1. 算子分类

Spark算子大体上分为两大类

  1. Transformation：操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发；
  2. Action：会触发 Spark 提交作业（Job），并将数据输出 Spark系统。

当然，对于transformation算子，如果要较真的话，还可以继续分一分

  1. Value数据类型的Transformation算子；
  2. Key-Value数据类型的Transfromation算子。

1.1 Value数据类型的Transformation算子

类型 算子
输入分区与输出分区一对一型 map、flatMap、mapPartitions、glom
输入分区与输出分区多对一型 union、cartesian
输入分区与输出分区多对多型 groupBy
输出分区为输入分区子集型 filter、distinct、subtract、sample、takeSample
Cache型 cache、persist

1.2 Key-Value数据类型的Transfromation算子

类型 算子
输入分区与输出分区一对一 mapValues
对单个RDD combineByKey、reduceByKey、partitionBy
两个RDD聚集 Cogroup
连接 join、leftOutJoin、rightOutJoin

1.3 Action算子

类型 算子
无输出 foreach
HDFS saveAsTextFile、saveAsObjectFile
Scala集合和数据类型 collect、collectAsMap、reduceByKeyLocally、lookup、count、top、reduce、fold、aggregate

2、Transformation算子详解

2.1 map

说明：

将原来RDD的每个数据项通过map中的用户自定义函数f映射转变为一个新的元素

Scala示例：

def map() {
    val conf = new SparkConf().setAppName(ScalaOperatorDemo.getClass.getSimpleName).setMaster("local")
    val sc = new SparkContext(conf)

    val datas: Array[String] = Array(
        "{'id':1,'name':'xl1','pwd':'xl123','sex':2}",
        "{'id':2,'name':'xl2','pwd':'xl123','sex':1}",
        "{'id':3,'name':'xl3','pwd':'xl123','sex':2}")

    sc.parallelize(datas)
        .map(v => {
            new Gson().fromJson(v, classOf[User])
        })
        .foreach(user => {
            println("id: " + user.id
                + " name: " + user.name
                + " pwd: " + user.pwd
                + " sex:" + user.sex)
        })
}
2.2 filter

说明：

对元素进行过滤，对每个元素应用f函数，返回值为true的元素在RDD中保留，返回为false的将过滤掉


Scala示例：

def filter() {
    val conf = new SparkConf().setAppName(ScalaOperatorDemo.getClass.getSimpleName).setMaster("local")
    val sc = new SparkContext(conf)

    val datas = Array(1, 2, 3, 7, 4, 5, 8)

    sc.parallelize(datas)
        .filter(v => v >= 3)
        .foreach(println)
}

2.3 flatMap

说明：

与map类似，但每个输入的RDD成员可以产生0或多个输出成员

Scala示例：

sc.parallelize(datas)
            .flatMap(line => line.split(","))
            .foreach(println)

2.4 mapPartitions

说明：

与map类似，但map中的func作用的是RDD中的每个元素，而mapPartitions中的func作用的对象是RDD的一整个分区，所以func的类型是Iterator


Scala示例：

sc.parallelize(datas, 3)
        .mapPartitions(
            n => {
                val result = ArrayBuffer[String]()
                while (n.hasNext) {
                    result.append(n.next())
                }
                result.iterator
            }
        )
        .foreach(println)


2.5 mapPartitionsWithIndex

说明：

与mapPartitions类似，但输入会多提供一个整数表示分区的编号，所以func的类型是(Int, Iterator)

Scala示例：

sc.parallelize(datas, 3)
        .mapPartitionsWithIndex(
            (m, n) => {
                val result = ArrayBuffer[String]()
                while (n.hasNext) {
                    result.append("分区索引:" + m + "\t" + n.next())
                }
                result.iterator
            }
        )
        .foreach(println)

2.6 sample


说明：

对RDD进行抽样，其中参数withReplacement为true时表示抽样之后还放回，可以被多次抽样，false表示不放回；fraction表示抽样比例；seed为随机数种子，比如当前时间戳

Scala示例：

sc.parallelize(datas)
        .sample(withReplacement = false, 0.5, System.currentTimeMillis)
        .foreach(println)

2.7 union

说明：

合并两个RDD，不去重，要求两个RDD中的元素类型一致

Scala示例：

// sc.parallelize(datas1)
//     .union(sc.parallelize(datas2))
//     .foreach(println)

// 或

(sc.parallelize(datas1) ++ sc.parallelize(datas2))
    .foreach(println)

2.8 intersection


说明：

返回两个RDD的交集

Scala示例：

sc.parallelize(datas1)
            .intersection(sc.parallelize(datas2))
            .foreach(println)

2.9 distinct

说明：

对原RDD进行去重操作，返回RDD中没有重复的成员


Scala示例：

sc.parallelize(datas)
    .distinct()
    .foreach(println)


2.10 groupByKey

说明：

对<key, value>结构的RDD进行类似RMDB的group by聚合操作，具有相同key的RDD成员的value会被聚合在一起，返回的RDD的结构是(key, Iterator<value>)

Scala示例：

def groupBy(sc: SparkContext): Unit = {
    sc.parallelize(1 to 9, 3)
        .groupBy(x => {
            if (x % 2 == 0) "偶数"
            else "奇数"
        })
        .collect()
        .foreach(println)

    val datas2 = Array("dog", "tiger", "lion", "cat", "spider", "eagle")
    sc.parallelize(datas2)
        .keyBy(_.length)
        .groupByKey()
        .collect()
        .foreach(println)
}// 结果(奇数,[1, 3, 5, 7, 9])(偶数,[2, 4, 6, 8])(4,[lion])(6,[spider])(3,[dog, cat])(5,[tiger, eagle])

2.11 reduceByKey

说明：

对<key, value>结构的RDD进行聚合，对具有相同key的value调用func来进行reduce操作，func的类型必须是(V, V) => V

Scala示例：

val textFile = sc.textFile("file:///home/zkpk/spark-2.0.1/README.md")
val words = textFile.flatMap(line => line.split(" "))
val wordPairs = words.map(word => (word, 1))
val wordCounts = wordPairs.reduceByKey((a, b) => a + b)
println("wordCounts: ")
wordCounts.collect().foreach(println)
// 结果package 1For 3Programs    1（略）

2.12 aggregateByKey

说明：

aggregateByKey函数对PairRDD中相同Key的值进行聚合操作，在聚合过程中同样使用了一个中立的初始值。和aggregate函数类似，aggregateByKey返回值得类型不需要和RDD中value的类型一致。因为aggregateByKey是对相同Key中的值进行聚合操作，所以aggregateByKey函数最终返回的类型还是Pair RDD，对应的结果是Key和聚合好的值；而aggregate函数直接返回非RDD的结果。

参数：

  1. zeroValue：表示在每个分区中第一次拿到key值时,用于创建一个返回类型的函数,这个函数最终会被包装成先生成一个返回类型,然后通过调用seqOp函数,把第一个key对应的value添加到这个类型U的变量中。
  2. seqOp：这个用于把迭代分区中key对应的值添加到zeroValue创建的U类型实例中。
  3. combOp：这个用于合并每个分区中聚合过来的两个U类型的值。

Scala示例：

def aggregateByKey(sc: SparkContext): Unit = {

    // 合并在同一个partition中的值，a的数据类型为zeroValue的数据类型，b的数据类型为原value的数据类型
    def seq(a:Int, b:Int): Int = {
        println("seq: " + a + "\t" + b)
        math.max(a, b)
    }

    // 合并在不同partition中的值，a,b的数据类型为zeroValue的数据类型
    def comb(a:Int, b:Int): Int = {
        println("comb: " + a + "\t" + b)
        a + b
    }

    // 数据拆分成两个分区
    // 分区一数据: (1,3) (1,2)
    // 分区二数据: (1,4) (2,3)
    // zeroValue 中立值，定义返回value的类型，并参与运算
    // seqOp 用来在一个partition中合并值的
    // 分区一相同key的数据进行合并
    // seq: 0   3  (1,3)开始和中位值合并为3
    // seq: 3   2  (1,2)再次合并为3
    // 分区二相同key的数据进行合并
    // seq: 0   4  (1,4)开始和中位值合并为4
    // seq: 0   3  (2,3)开始和中位值合并为3
    // comb 用来在不同partition中合并值的
    // 将两个分区的结果进行合并
    // key为1的, 两个分区都有, 合并为(1,7)
    // key为2的, 只有一个分区有, 不需要合并(2,3)
    sc.parallelize(List((1, 3), (1, 2), (1, 4), (2, 3)), 2)
        .aggregateByKey(0)(seq, comb)
        .collect()
        .foreach(println)
}

// 结果
(2,3)
(1,7)

2.13 sortByKey

说明：

对<key, value>结构的RDD进行升序或降序排列

参数：

  1. comp：排序时的比较运算方式。
  2. ascending：false降序；true升序。

Scala示例：

def sortByKey(sc: SparkContext) : Unit = {
    sc.parallelize(Array(60, 70, 80, 55, 45, 75))
        .sortBy(v => v, false)
        .foreach(println)

    sc.parallelize(List((3, 3), (2, 2), (1, 4), (2, 3)))
        .sortByKey(true)
        .foreach(println)
}// 结果807570605545(3,3)(2,2)(2,3)(1,4)

2.14 join

说明：

对<K, V>和<K, W>进行join操作，返回(K, (V, W))外连接函数为leftOuterJoin、rightOuterJoin和fullOuterJoin

Scala示例：

sc.parallelize(List((1, "苹果"), (2, "梨"), (3, "香蕉"), (4, "石榴")))
        .join(sc.parallelize(List((1, 7), (2, 3), (3, 8), (4, 3), (5, 9))))
        .foreach(println)

   
   

    
    // 结果
   
   

   
   

    
    (
    
    4
    
    ,(石榴,
    
    3
    
    ))
   
   

   
   

    
    (
    
    1
    
    ,(苹果,
    
    7
    
    ))
   
   

   
   

    
    (
    
    3
    
    ,(香蕉,
    
    8
    
    ))
   
   

   
   

    
    (
    
    2
    
    ,(梨,
    
    3
    
    ))

2.15 cogroup

说明：

cogroup:对多个RDD中的KV元素，每个RDD中相同key中的元素分别聚合成一个集合，与reduceByKey不同的是针对两个RDD中相同的key的元素进行合并。

Scala示例：

def cogroup(sc: SparkContext): Unit = {
    val datas1 = List((1, "苹果"),
        (2, "梨"),
        (3, "香蕉"),
        (4, "石榴"))

    val datas2 = List((1, 7),
        (2, 3),
        (3, 8),
        (4, 3))


    val datas3 = List((1, "7"),
        (2, "3"),
        (3, "8"),
        (4, "3"),
        (4, "4"),
        (4, "5"),
        (4, "6"))

    sc.parallelize(datas1)
        .cogroup(sc.parallelize(datas2),
            sc.parallelize(datas3))
        .foreach(println)
}

// 结果
(4,(CompactBuffer(石榴),CompactBuffer(3),CompactBuffer(3, 4, 5, 6)))
(1,(CompactBuffer(苹果),CompactBuffer(7),CompactBuffer(7)))
(3,(CompactBuffer(香蕉),CompactBuffer(8),CompactBuffer(8)))
(2,(CompactBuffer(梨),CompactBuffer(3),CompactBuffer(3)))

2.16 cartesian

说明：

两个RDD进行笛卡尔积合并

Scala示例：

namesRDD.cartesian(scoreRDD)
            .foreach(println)// 结果张三  60张三  70张三  80李四  60李四  70李四  80王五  60王五  70王五  80

2.17 pipe

说明：

执行cmd命令，创建RDD

Scala示例：

echo.sh内容

#!/bin/bash
echo "Running shell script"
RESULT=""
while read LINE; do
  RESULT=${RESULT}" "${LINE}
done

echo ${RESULT} > /Users/zhangws/out123.txt
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

   
   

    
    
   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

测试代码

def pipe(sc: SparkContext): Unit = {
    val data = List("hi", "hello", "how", "are", "you")
    sc.makeRDD(data)
        .pipe("/Users/zhangws/echo.sh")
        .collect()
        .foreach(println)
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

结果

# out123.txt
hi hello how are you

# 输出
Running shell script

2.18 coalesce

说明：

用于将RDD进行重分区，使用HashPartitioner，且该RDD的分区个数等于numPartitions个数，如果shuffle设置为true，则会进行shuffle。

Scala示例：

def coalesce(sc: SparkContext): Unit = {
    val datas = List("hi", "hello", "how", "are", "you")
    val datasRDD = sc.parallelize(datas, 4)
    println("RDD的分区数: " + datasRDD.partitions.length)
    val datasRDD2 = datasRDD.coalesce(2)
    println("RDD的分区数: " + datasRDD2.partitions.length)
}// 结果RDD的分区数: 4RDD的分区数: 2

2.19 repartition


说明：

该函数其实就是coalesce函数第二个参数为true的实现

2.20 repartitionAndSortWithinPartitions


说明：

根据给定的Partitioner重新分区，并且每个分区内根据comp实现排序。

Scala示例

def repartitionAndSortWithinPartitions(sc: SparkContext): Unit = {

    def partitionFunc(key:String): Int = {
        key.substring(7).toInt
    }

    val datas = new Array[String](1000)
    val random = new Random(1)
    for (i <- 0 until 10; j <- 0 until 100) {
        val index: Int = i * 100 + j
        datas(index) = "product" + random.nextInt(10) + ",url" + random.nextInt(100)
    }
    val datasRDD = sc.parallelize(datas)
    val pairRDD = datasRDD.map(line => (line, 1))
        .reduceByKey((a, b) => a + b)
//        .foreach(println)

    pairRDD.repartitionAndSortWithinPartitions(new Partitioner() {
        override def numPartitions: Int = 10

        override def getPartition(key: Any): Int = {
            val str = String.valueOf(key)
            str.substring(7, str.indexOf(',')).toInt
        }
    }).foreach(println)
}// 结果(product00,url099)(product00,url006)(product00,url088)略(product09,url004)(product09,url021)(product09,url036)

3. Action

3.1 reduce

说明：

对RDD成员使用func进行reduce操作，func接受两个参数，合并之后只返回一个值。reduce操作的返回结果只有一个值。需要注意的是，func会并发执行

Scala示例：

def reduce(sc: SparkContext): Unit = {
    println(sc.parallelize(1 to 10)
        .reduce((x, y) => x + y))
}

// 结果
55

3.2 collect

说明：

将RDD读取至Driver程序，类型是Array，一般要求RDD不要太大。

3.3 count


说明：

返回RDD的成员数量

Scala示例：

def count(sc: SparkContext): Unit = {
    println(sc.parallelize(1 to 10)
        .count)
}

// 结果
10

3.4 first

说明：

返回RDD的第一个成员，等价于take(1)

Scala示例：

def first(sc: SparkContext): Unit = {
    println(sc.parallelize(1 to 10)
        .first())
}

// 结果
1

3.5 take

说明：

返回RDD前n个成员

Scala示例：

def take(sc: SparkContext): Unit = {
    sc.parallelize(1 to 10)
        .take(2).foreach(println)
}

// 结果
1
2

3.6 takeSample

说明：

和sample用法相同，只不第二个参数换成了个数。返回也不是RDD，而是collect。

Scala示例：

def takeSample(sc: SparkContext): Unit = {
    sc.parallelize(1 to 10)
        .takeSample(withReplacement = false, 3, 1)
        .foreach(println)
}

// 结果
1
8
10

3.7 takeOrdered

说明：

用于从RDD中，按照默认（升序）或指定排序规则，返回前num个元素。

Scala示例：

def takeOrdered(sc: SparkContext): Unit = {
    sc.parallelize(Array(5,6,2,1,7,8))
        .takeOrdered(3)(new Ordering[Int](){
            override def compare(x: Int, y: Int): Int = y.compareTo(x)
        })
        .foreach(println)
}

// 结果
8
7
6

3.8 saveAsTextFile

说明：

将RDD转换为文本内容并保存至路径path下，可能有多个文件(和partition数有关)。路径path可以是本地路径或HDFS地址，转换方法是对RDD成员调用toString函数

Scala示例：

def saveAsTextFile(sc: SparkContext): Unit = {
    sc.parallelize(Array(5,6,2,1,7,8))
            .saveAsTextFile("/Users/zhangws/Documents/test")
}

// 结果
/Users/zhangws/Documents/test目录下
_SUCCESS
part-00000

// part-00000文件内容
5
6
2
1
7
8

3.9 saveAsSequenceFile

说明：

与saveAsTextFile类似，但以SequenceFile格式保存，成员类型必须实现Writeable接口或可以被隐式转换为Writable类型（比如基本Scala类型Int、String等）

3.10 saveAsObjectFile

说明：

用于将RDD中的元素序列化成对象，存储到文件中。对于HDFS，默认采用SequenceFile保存。

3.11 countByKey

说明：

仅适用于(K, V)类型，对key计数，返回(K, Int)

Scala示例：

def reduce(sc: SparkContext): Unit = {
    println(sc.parallelize(Array(("A", 1), ("B", 6), ("A", 2), ("C", 1), ("A", 7), ("A", 8)))
            .countByKey())
}

// 结果
Map(B -> 1, A -> 4, C -> 1)

3.12 foreach

说明：

对RDD中的每个成员执行func，没有返回值，常用于更新计数器或输出数据至外部存储系统。这里需要注意变量的作用域

wangjinnan16
关注
专栏目录
Spark算子使用示例
梓纾的专栏
11-05 1万+
1. 算子分类从大方向来说，Spark 算子大致可以分为以下两类 Transformation：操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。 Action：会触发 Spark 提交作业（Job），并将数据输出 Spark系统。 从小方向来说，Spark 算子大致可以分为以下三类: Value数据类型的T
spark算子大全glom_Spark算子总结及案例
weixin_39593523的博客
12-19 330
spark算子大致上可分三大类算子：1、Value数据类型的Transformation算子，这种变换不触发提交作业，针对处理的数据项是Value型的数据。2、Key-Value数据类型的Transformation算子，这种变换不触发提交作业，针对处理的数据项是Key-Value型的数据。3、Action算子，这类算子会触发SparkContext提交作业。一、Value型Transformat...
大数据编程技术——期末复习
weixin_44436319的博客
12-09 5073
考试方式： 闭卷笔试（网上阅卷） 题型： 单选题30分 多选题20分 程序题30分 问答题20分 （以下标注重点的项目有可能出现在主观题中） 一 Scala Scala语言特点 Lambda演算的概念 类（静态类和动态类）、方法和函数的声明 数据类型，Int、String、Double、Boolean、Array、List、Map、Tuple 常量和变量的声明 运算符，特别注意Lambda运算符 选择语句 for循环语句（能看懂即可） Array、List、Tuple的声明和使用 函数与方法的区别（重点）
Spark函数算子及示例
Joker_Jiang3的博客
07-04 412
Spark函数/算子 一、集合算子 1、没有key的聚合函数 sum reduce fold aggregate package com.jiang.hello import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} object RDD_aggregate_NoKey { def main(args: Array[String]): Unit = { val conf:Spark
Spark SQL DataFrame 算子
最新发布
2401_84052244的博客
07-31 420
DataFrame 算子与 SQL 查询语句之间，并没有优劣之分，他们可以实现同样的数据应用，而且在执行性能方面也是一致的。因此，你可以结合你的开发习惯与偏好，自由地在两者之间进行取舍。DataFrame 本身支持的算子之外，在功能上，SQL 完全可以实现同样的数据分析。给定 DataFrame，你只需通过 createTempView 或是 createGlobalTempView 来创建临时表，然后就可以通过写 SQL 语句去进行数据的探索、倾斜、转换与分析。
Spark常用的算子以及Scala函数总结.pdf
05-17
Apache Spark 是一个开源的分布式计算系统，提供了一个快速、通用的引擎，用于大规模数据处理。它是一个基于内存计算的大数据处理框架，...在学习 Spark 编程时，熟悉这些算子和 Scala 的函数式编程特性是非常重要的。
Spark学习笔记11:RDD算子
balabalalibala的博客
05-20 1024
RDD 算子
spark 常用算子大全（分类详细，图片解析）
BigData_Hubert的博客
09-25 9467
scala 系列 spark 常用算子大全 scala 常用算子大全scala 系列前言思维导图 前言 上一篇博客已经给大家介绍了 scala OOP， 掌握了OOP 的知识后，就已经算是进入 scala 的门了。scala OOP基础是 spark 和 flink 的基础。 本篇博客将为大家带来 scala 高级扩展的介绍。主要包括模式匹配和正则表达式，此外还有异常处理、注解和高级类型的简单了解。 思维导图 ...
Spark基础学习：掌握RDD算子（3）
weixin_54425212的博客
06-16 1503
RDD
spark例子整理
大浩劫的博客
06-17 2494
Spark Streaming是一个准实时流处理框架，处理响应时间一般以分钟为单位，也就是说处理实时数据的延迟时间是秒级别的；Storm是一个实时流处理框架，处理响应是毫秒级的。所以在流框架选型方面要看具体业务场景。需要澄清的是现在很多人认为Spark Streaming流处理运行不稳定、数据丢失、事务性支持不好等等，那是因为很多人不会驾驭Spark Streaming及Spark本身。在Spar
Spark算子详解及案例分析
MY BLOG
08-22 1231
原文：https://cloud.tencent.com/developer/article/1085207 目录 一、分类 二、Value型Transformation算子 三、Key-Value型Transformation算子 输入输出分区1对1 聚集 连接 四、Actions算子 一、分类 1、Value数据类型的Transformation算子，这种变换不触发提交作业，针对处理的数据项是Value型的数据。 　　 2、Key-Value数据类型的Transformation算
spark常用算子总结（附加代码示例）
Peanut的博客
09-25 2851
文章目录简介Transformation转换算子value类型1.map（）2.mapPartitions（）3.mapPartitionsWithIndex()4.flatMap（）5.glom（）6.groupBy（）7.filter（）8.sample（）9.distinct（）10.coalesce（）11.reparation（）12.sortBy（）13.pipe（）双value类型1.union（）并集2.intersection（）交集3.subtract （）差集4. zip（）拉链Key
Scala Spark的使用
qq_22511813的博客
11-13 681
SparkContext的创建 "#创建一个SparkConf" val work: SparkConf = new SparkConf().setMaster("local[*]").setAppName("work") "#创建一个SparkContext" val sc = new SparkContext(work) Spark的基本操作 "#从内存中创建一个RDD" val listR...
【Spark】Spark的常用算子
weixin_46429290的博客
03-07 2805
使用给定的函数对 RDD 的元素进行聚合，seqOp 计算在分区中初始值到中间结果的聚合计算，而 combOp 在节点上对中间结果进行聚合。: 返回对输入 RDD 和参数 RDD 执行联合操作的结果，生成一个新的 RDD，不去重。: 返回对输入 RDD 和参数 RDD 执行交集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行差集操作的结果，生成一个新的 RDD。: 返回对输入 RDD 和参数 RDD 执行笛卡尔积的结果，生成一个新的 RDD。
Spark API 之 takeSample(boolean, sampleNum,seed) 详解
qq_29499107的博客
06-27 3853
takeSample(boolean, sampleNum,seed)：该函数是抽取随机数。前言：很重要，不然你不会理解seed的作用。用算法进行算出的结果为伪随机数，因为算法是固定的，只是我们在改变其参数而已，要知道在java中的Random类产生的数就是伪随机数，底层有一套自己的算法，该算法依靠seed（种子）参数，如果种子一样得到的结果也一样，而我们通常在开发中大部分是使用 new Rand...
Spark之takeSample执行算子
qq_34341930的博客
05-05 621
takeSample 返回一个Array[T]； 该方法仅在预期结果数组很小的情况下使用，因为所有数据都被加载到driver的内存中。 源码 def takeSample( withReplacement: Boolean, num: Int, seed: Long = Utils.random.nextLong): Array[T] = withScope {...} ...
Spark的算子的分类
King_S_H的博客
06-11 5351
从大方向来说，Spark 算子大致可以分为以下两类: 1）Transformation 变换/转换算子：这种变换并不触发提交作业，完成作业中间过程处理。　　　Transformation 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。 2）Action 行动算子：这类算子会触发 SparkContext 提交 Job 作业。　　 Action 算子会触发 Spark 提交作业（Job），并将数据
scala常用算子
m0_56280960的博客
08-10 301
scala常用算子 提取元素 val v:T = arr.head #Array(1, 2, 3).head =>1 提取数组第一个元素 val v:Option[T] = arr.headOption #Array(1, 2, 3).headOption => Some(1) val v:T = arr.last # Array(1, 2, 3).last =>3 提取数组最后一个元素 val v:T = arr(index:Int) #println(arr1(2)) =>3 v
携程实时计算平台：基于SparkStreaming的构建实践
在这个过程中，SparkStreaming逐渐成为构建实时计算平台的重要工具，以解决JStorm在功能抽象、集成度和与离线计算统一等方面的不足。 1. SparkStreaming vs JStorm 在接入SparkStreaming之前，JStorm是携程实时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值