Spark总结整理(二)：Spark Transformation和Action整理

最新推荐文章于 2022-03-31 16:51:58 发布
最新推荐文章于 2022-03-31 16:51:58 发布
阅读量314 收藏
点赞数
分类专栏： # SparkCore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super_wj0820/article/details/100537277
版权

本篇文章主要介绍：

  1. Transformation 与 Action 常用API 速览
  2. Transformation 与 Action 常用API DEMO

1. Transformation 与 Action 常用API

Spark支持两个类型（算子）操作：Transformation和Action

1.1Transformation

将一个已有的RDD生成另外一个RDD。

Transformation 具有 lazy 特性(延迟加载)。

Transformation 算子的代码不会真正被执行。只有当我们的程序里面遇到一个action算子的时候，代码才会真正的被执行。

这种设计让Spark更加有效率地运行。

转换含义
map(func)返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
filter(func)返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
flatMap(func)类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
mapPartitions(func)类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是：Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是：(Int, Interator[T]) => Iterator[U]
sample(withReplacement, fraction, seed)根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset)对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset)对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks]))对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])先按分区聚合 再总的聚合 每次要跟初始值交流 例如：aggregateByKey(0)(+,+) 对k/y的RDD进行操作
sortByKey([ascending], [numTasks])在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])与sortByKey类似，但是更灵活 第一个参数是根据什么排序 第二个是怎么排序 false倒序 第三个排序后分区数 默认与原RDD一样
join(otherDataset, [numTasks])在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD 相当于内连接（求交集）
cogroup(otherDataset, [numTasks])在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
cartesian(otherDataset)两个RDD的笛卡尔积 的成很多个K/V
pipe(command, [envVars])调用外部程序
coalesce(numPartitions)重新分区 第一个参数是要分多少区，第二个参数是否shuffle 默认false 少分区变多分区 true 多分区变少分区 false
repartition(numPartitions)重新分区 必须shuffle 参数是要分多少区 少变多
repartitionAndSortWithinPartitions(partitioner)重新分区+排序 比先分区再排序效率高 对K/V的RDD进行操作
foldByKey(zeroValue)(seqOp)该函数用于K/V做折叠，合并处理 ，与aggregate类似 第一个括号的参数应用于每个V值 第二括号函数是聚合例如：+
combineByKey合并相同的key的值 rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
partitionBy（partitioner）对RDD进行分区 partitioner是分区器 例如 new HashPartition(2)
cacheRDD缓存，可以避免重复计算从而减少时间，区别：cache内部调用了persist算子，cache默认就一个缓存级别MEMORY-ONLY ，而persist则可以选择缓存级别
persistRDD缓存，可以避免重复计算从而减少时间，区别：cache内部调用了persist算子，cache默认就一个缓存级别MEMORY-ONLY ，而persist则可以选择缓存级别
Subtract（rdd）返回前rdd元素不在后rdd的rdd
leftOuterJoinleftOuterJoin类似于SQL中的左外关联left outer join，返回结果以前面的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可。
rightOuterJoinrightOuterJoin类似于SQL中的有外关联right outer join，返回结果以参数中的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可
subtractByKeysubstractByKey和基本转换操作中的subtract类似只不过这里是针对K的，返回在主RDD中出现，并且不在otherRDD中出现的元素

1.2 Action

触发代码的运行，我们一段spark代码里面至少需要有一个action操作

动作含义
reduce(func)通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
collect()在驱动程序中，以数组的形式返回数据集的所有元素
count()返回RDD的元素个数
first()返回RDD的第一个元素（类似于take(1)）
take(n)take用于获取RDD中从0到num-1下标的元素，不排序
takeSample(withReplacement,num, [seed])返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])takeOrdered和top类似，只不过以和top相反的顺序返回元素。
saveAsTextFile(path)将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)写HDFS
countByKey()针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)在数据集的每一个元素上，运行函数func进行更新。
aggregate先对分区进行操作，在总体操作
reduceByKeyLocally该函数将RDD[K,V]中每个K对应的V值根据映射函数来运算，运算结果映射到一个Map[K,V]中，而不是RDD[K,V]
lookuplookup用于(K,V)类型的RDD,指定K值，返回RDD中该K对应的所有V值
toptop函数用于从RDD中，按照默认（降序）或者指定的排序规则，返回前num个元素。
foldfold是aggregate的简化，将aggregate中的seqOp和combOp使用同一个函数op
foreachPartition针对各分区的数据进行处理

API DEMO

package com.wj.spark;

import org.apache.spark.HashPartitioner;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.junit.Before;
import org.junit.Test;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * Transformation DEMO
 */
public class TransformationTest {

    static SparkConf conf;
    static JavaSparkContext sc;

    @Before
    public void setup() {
        conf = new SparkConf();
        conf.setMaster("local").setAppName("TestTransformation");
        sc = new JavaSparkContext(conf);
    }

    @Test
    public void testMap() {
        String[] names = {"张无忌", "赵敏", "周芷若"};

        JavaRDD<String> listRDD = sc.parallelize(Arrays.asList(names));

        JavaRDD<String> nameRDD = listRDD.map(name -> "Hello " + name);

        nameRDD.foreach(name -> System.out.println(name));
    }

    @Test
    public void testFlatMap() {
        List<String> list = Arrays.asList("张无忌 赵敏", "宋青书 周芷若");

        JavaRDD<String> listRDD = sc.parallelize(list);

        JavaRDD<String> nameRDD = listRDD
                .flatMap(line -> Arrays.asList(line.split(" ")).iterator())
                .map(name -> "Hello " + name);

        nameRDD.foreach(name -> System.out.println(name));
    }

    /**
     * <pre>
     *      map:
     *          一条数据一条数据的处理（文件系统，数据库等等）
     *      mapPartitions：
     *          一次获取的是一个分区的数据（hdfs）
     *
     *      正常情况下，mapPartitions 是一个高性能的算子
     *
     *      因为每次处理的是一个分区的数据，减少了去获取数据的次数
     *
     *      但是分区如果设置得不合理，有可能导致每个分区里面的数据量过大
     * </pre>
     */
    @Test
    public void testMapPartitions() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        JavaRDD<Integer> listRDD = sc.parallelize(list, 3);

        JavaRDD<String> rdd = listRDD.mapPartitions(iterator -> {
            ArrayList<String> array = new ArrayList<>();
            while (iterator.hasNext()) {
                array.add("hello " + iterator.next());
            }
            return array.iterator();
        });

        rdd.foreach(name -> System.out.println(name));
    }


    @Test
    public void testMapPartitionsWithIndex() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        JavaRDD<Integer> listRDD = sc.parallelize(list, 2);

        JavaRDD<String> rdd = listRDD.mapPartitionsWithIndex((index, iterator) -> {
            ArrayList<String> list1 = new ArrayList<>();
            while (iterator.hasNext()) {
                list1.add(index + "_" + iterator.next());
            }
            return list1.iterator();
        }, true);

        rdd.foreach(str -> System.out.println(str));
    }

    @Test
    public void reduce() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        JavaRDD<Integer> listRDD = sc.parallelize(list);

        System.out.println(listRDD.reduce(Integer::sum));
    }

    @Test
    public void reduceByKey() {
        List<Tuple2<String, Integer>> list = Arrays.asList(
                new Tuple2<>("武当", 99),
                new Tuple2<>("少林", 97),
                new Tuple2<>("武当", 89),
                new Tuple2<>("少林", 77)
        );
        JavaPairRDD<String, Integer> listRDD = sc.parallelizePairs(list);

        JavaPairRDD<String, Integer> resultRDD = listRDD.reduceByKey(Integer::sum);

        resultRDD.foreach(tuple -> System.out.println("门派: " + tuple._1 + " -> " + tuple._2));
    }

    @Test
    public void union() {
        final List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        final List<Integer> list2 = Arrays.asList(3, 4, 5, 6);
        final JavaRDD<Integer> rdd1 = sc.parallelize(list1);
        final JavaRDD<Integer> rdd2 = sc.parallelize(list2);

        rdd1.union(rdd2).foreach(num -> System.out.println(num));
    }

    @Test
    @SuppressWarnings("unchecked")
    public void groupByKey() {
        List<Tuple2<String, String>> list = Arrays.asList(
                new Tuple2("武当", "张三丰"),
                new Tuple2("峨眉", "灭绝师太"),
                new Tuple2("武当", "宋青书"),
                new Tuple2("峨眉", "周芷若")
        );
        JavaPairRDD<String, String> listRDD = sc.parallelizePairs(list);

        JavaPairRDD<String, Iterable<String>> groupByKeyRDD = listRDD.groupByKey();
        groupByKeyRDD.foreach(tuple -> {
            String menpai = tuple._1;
            Iterator<String> iterator = tuple._2.iterator();

            StringBuilder people = new StringBuilder();
            while (iterator.hasNext()) {
                people.append(iterator.next()).append(" ");
            }
            System.out.println("门派 : " + menpai + ";  人员 : " + people);
        });
    }

    @Test
    public void join() {
        final List<Tuple2<Integer, String>> names = Arrays.asList(
                new Tuple2<>(1, "东方不败"),
                new Tuple2<>(2, "令狐冲"),
                new Tuple2<>(3, "林平之")
        );
        final List<Tuple2<Integer, Integer>> scores = Arrays.asList(
                new Tuple2<>(1, 99),
                new Tuple2<>(2, 98),
                new Tuple2<>(3, 97)
        );

        final JavaPairRDD<Integer, String> namesRdd = sc.parallelizePairs(names);
        final JavaPairRDD<Integer, Integer> scoresRdd = sc.parallelizePairs(scores);

        final JavaPairRDD<Integer, Tuple2<String, Integer>> joinRDD = namesRdd.join(scoresRdd);
        joinRDD.foreach(tuple -> System.out.println("学号:" + tuple._1 + "; 姓名:" + tuple._2._1 + "; 成绩:" + tuple._2._2));
    }

    @Test
    public void sample() {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            list.add(i);
        }
        JavaRDD<Integer> listRDD = sc.parallelize(list);

        JavaRDD<Integer> sampleRDD = listRDD.sample(false, 0.1, 0);
        sampleRDD.foreach(num -> System.out.print(num + " "));
    }

    @Test
    public void cartesian() {
        List<String> list1 = Arrays.asList("A", "B");
        List<Integer> list2 = Arrays.asList(1, 2, 3);
        JavaRDD<String> list1RDD = sc.parallelize(list1);
        JavaRDD<Integer> list2RDD = sc.parallelize(list2);
        list1RDD.cartesian(list2RDD).foreach(tuple -> System.out.println(tuple._1 + " -> " + tuple._2));
    }

    @Test
    public void filter() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        JavaRDD<Integer> listRDD = sc.parallelize(list);
        JavaRDD<Integer> filterRDD = listRDD.filter(num -> num % 2 == 0);
        filterRDD.foreach(num -> System.out.print(num + " "));
    }

    @Test
    public void distinct() {
        List<Integer> list = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5);
        JavaRDD<Integer> listRDD = sc.parallelize(list);
        listRDD.distinct().foreach(num -> System.out.println(num));
    }

    @Test
    public void intersection() {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6);
        JavaRDD<Integer> list1RDD = sc.parallelize(list1);
        JavaRDD<Integer> list2RDD = sc.parallelize(list2);
        list1RDD.intersection(list2RDD).foreach(num -> System.out.println(num));
    }

    /**
     * 分区数由多 -> 变少 （如过滤部分数据后，数据量减少，可以缩减Task）
     */
    @Test
    public void coalesce() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        JavaRDD<Integer> listRDD = sc.parallelize(list, 3);
        listRDD.coalesce(1).foreach(num -> System.out.println(num));
    }

    /**
     * 进行重分区，解决的问题：本来分区数少 -> 增加分区数
     */
    @Test
    public void replication() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        JavaRDD<Integer> listRDD = sc.parallelize(list, 1);
        listRDD.repartition(2).foreach(num -> System.out.println(num));
    }

    /**
     * repartitionAndSortWithinPartitions 函数是 repartition 函数的变种
     * <p>
     * 与 repartition 函数不同的是，repartitionAndSortWithinPartitions 在给定的 partitioner 内部进行排序，性能比repartition要高
     */
    @Test
    public void repartitionAndSortWithinPartitions() {
        List<Integer> list = Arrays.asList(1, 4, 55, 66, 33, 48, 23);
        JavaRDD<Integer> listRDD = sc.parallelize(list, 1);

        JavaPairRDD<Integer, Integer> pairRDD = listRDD.mapToPair(num -> new Tuple2<>(num, num));
        JavaRDD<String> rdd = pairRDD.repartitionAndSortWithinPartitions(new HashPartitioner(3))
                .mapPartitionsWithIndex((index, iterator) -> {
                    ArrayList<String> list1 = new ArrayList<>();
                    while (iterator.hasNext()) {
                        list1.add(index + "_" + iterator.next());
                    }
                    return list1.iterator();
                }, false);
        rdd.foreach(str -> System.out.println(str));
    }

    /**
     * 对两个RDD 中的 KV 元素，每个RDD中相同 key 中的元素分别聚合成一个集合
     * <p>
     * 与 reduceByKey 不同的是针对两个RDD中相同的 key 的元素进行合并
     */
    @Test
    public void cogroup() {
        List<Tuple2<Integer, String>> list1 = Arrays.asList(
                new Tuple2<>(1, "www"),
                new Tuple2<>(1, "qqq"),
                new Tuple2<>(2, "bbs")
        );

        List<Tuple2<Integer, String>> list2 = Arrays.asList(
                new Tuple2<>(1, "cnblog"),
                new Tuple2<>(2, "cnblog"),
                new Tuple2<>(3, "very")
        );

        List<Tuple2<Integer, String>> list3 = Arrays.asList(
                new Tuple2<>(1, "com"),
                new Tuple2<>(2, "com"),
                new Tuple2<>(3, "good")
        );

        JavaPairRDD<Integer, String> list1RDD = sc.parallelizePairs(list1);
        JavaPairRDD<Integer, String> list2RDD = sc.parallelizePairs(list2);
        JavaPairRDD<Integer, String> list3RDD = sc.parallelizePairs(list3);

        list1RDD.cogroup(list2RDD, list3RDD).foreach(tuple ->
                System.out.println(tuple._1 + " " + tuple._2._1() + " " + tuple._2._2() + " " + tuple._2._3()));
    }

    @Test
    public void sortByKey() {
        List<Tuple2<Integer, String>> list = Arrays.asList(
                new Tuple2<>(99, "张三丰"),
                new Tuple2<>(96, "东方不败"),
                new Tuple2<>(66, "林平之"),
                new Tuple2<>(98, "聂风")
        );
        JavaPairRDD<Integer, String> listRDD = sc.parallelizePairs(list);
        listRDD.sortByKey(false).foreach(tuple -> System.out.println(tuple._2 + "->" + tuple._1));
    }

    @Test
    public void aggregateByKey() {
        List<String> list = Arrays.asList("you,jump", "i,jump");
        JavaRDD<String> listRDD = sc.parallelize(list);

        listRDD.flatMap(line -> Arrays.asList(line.split(",")).iterator())
                .mapToPair(word -> new Tuple2<>(word, 1))
                .aggregateByKey(0, (x, y) -> x + y, (m, n) -> m + n)
                .foreach(tuple -> System.out.println(tuple._1 + " -> " + tuple._2));
    }

    @Test
    public void aggregateByKey_2() {
        List<String> list = Arrays.asList("you,jump", "i,jump");
        JavaRDD<String> listRDD = sc.parallelize(list,2);

        listRDD.flatMap(line -> Arrays.asList(line.split(",")).iterator())
                .mapToPair(word -> new Tuple2<>(word, 1))
                .aggregateByKey(0, (x, y) -> (x + y) * 10, (m, n) -> m + n)
                .foreach(tuple -> System.out.println(tuple._1 + " -> " + tuple._2));
    }


}
super_man_0820
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Spark基础]-- spark的transformation和action算子(基本操作)
欢迎来到我的博客，一起探索代码里的世界！
08-23 2755
一、transform操作 1、map(func)  返回一个新的分布式数据集，由每个原元素经过func函数处理后的新元素组成  2、filter(func)  返回一个新的数据集，由经过func函数处理后返回值为true的原元素组成  3、flatMap(func)  类似于map，但是每一个输入元素，会被映射为0个或多个输出元素，(因此，func函数的返回值是一个seq，而不是单一元素)  4...
sortBy是一个action
siyueabc的博客
05-20 227
val conf = new SparkConf().setAppName("ScalaWordCount").setMaster("local[4]") //创建spark执行的入口 val sc = new SparkContext(conf) //指定以后从哪里读取数据创建RDD（弹性分布式数据集） val lines: RDD[String] = sc.textFile("/D:/a.txt") //切分压平 val words: RDD[S...
Spark transformation算子案例
呼呼的小窝
09-09 791
Spark支持两种RDD操作：transformation和action 在本文中，将对几个常用的transformation算子进行案例演示，采用Java和Scala两种语言对代码进行编写 其中，在Java版本中，将对transformation算子进行详细介绍transformation常用算子介绍
Spark Transformation 算子总结笔记
qq_43224174的博客
03-31 1009
由于本篇文章写的内容多，且杂，加上本人在写的过程中还加入了大量解释，为此本篇文章会设置成粉丝可见，请谅解！ 本篇文章主要包含了Spark Transformation 算子的value算子（ 1、map()映射 2、mapPartitions()以分区为单位执行Map map()和mapPartition()的区别： 3、mapPartitionsWithIndex()带分区号 4、flatMap()扁平化 6、groupBy()分组（包含四种方法取首字母） 7、GroupBy()之WordCount
[Spark学习04]Spark Transformation和Action
gefeng1209的博客
12-19 137
4.1 Transformation算子 基本初始化 private val conf: SparkConf = new SparkConf().setAppName("TestTransformation").setMaster("local") private val sparkContext = new SparkContext(conf) 4.2 map、flatMap、map...
Spark-Transformation和Action算子.md
08-09
Spark_Transformation和Action算子.md
Spark Transformation和Action算子速查表.pdf
05-17
spark transformation & action 算子速查表，大数据实时和离线数据处理方向，希望对大家学习和工作有所帮助。
spark面试题整理.pdf
最新发布
05-15
6. 解释Spark中的转换（Transformation）和动作（Action）。 7. Spark支持哪些语言进行数据处理？ 8. 什么是Spark的Lineage（血统）？ 9. 解释广播变量和累加器。 10. Spark SQL是什么，它有什么优势？ 11. 什么是...
spark考试练习题含答案.rar
06-22
5. **Transformation与Action**：Spark操作主要分为两类：转换（Transformation）和动作（Action）。转换定义了数据处理逻辑，而动作触发实际计算。 二、Spark编程模型 1. **Spark Shell**：交互式的命令行工具，...
大数据spark实验报告
05-12
RDDs分为两种类型：转换（Transformation）和行动（Action）。转换创建新的RDD，而行动触发计算并返回结果。 ### 实验环境与配置 实验通常在Hadoop YARN或standalone模式下进行，确保Spark与HDFS的无缝集成。配置...
spark之算子--transformation和action
qq_34382453的博客
12-20 758
摘要   spark的RDD具有延迟计算的特性，spark有两种操作算子，一种是transformation，一种是action。tranformation是来创建RDD的，它有可能从文件创建，也可能集合中创建，也可能依赖其它RDD创建。当算子为transformation的时候，spark并不执行计算操作，只有当遇到action算子的时候才开始计算。这就是transformation的lazy特...
Spark学习之路（四）【RDD编程 API——动作算子Action】
高興
06-25 324
RDD编程API Spark支持两个类型（算子）操作：Transformation和Action Action 触发代码的运行，我们一段spark代码里面至少需要有一个action操作。 常用的Action 动作 含义 reduce(func) 通过func函数聚集RDD中的所有元素，这个功能必须是课交换且可并联的 collect() 在驱动程序中，以数组的形式返回数据集的所有...
Spark Streaming入门 - 数据处理api - transformToPair
小哇
04-28 376
大白话理解：每个流式的Dstream，其实底层也是通过rdd来操作，transform就是将Dstream转成rdd，就可以和其他的普通的rdd做各种运算操作1 新建zidian.txt文件 24##少林寺欲将功夫融入足球培训运动员 25##北京警方捣毁侵害公民信息团伙抓获299人 26##北京发布雷电黄色预警傍晚至夜间将有大到暴雨 27##聚划算成清仓专用问题产品充斥 28##七夕前夜英仙座流星雨助兴我国处于最佳观测区 30##报告称中国取代英国成世界第5大常规武器出口国 2在158.158.4..
spark Rdd 操作transformaction和action等
weixin_33898233的博客
02-25 343
为什么80%的码农都做不了架构师？>>> ...
spark中 transformation和action介绍
旧时明月
09-06 716
spark中 transformation和action介绍 Spark支持两种RDD操作：transformation和action。transformation操作会针对已有的RDD创建一个新的RDD；而action则主要是对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并可以返回结果给Driver程序。 例如，map就是一种transformation操作，它用于将已有RDD的每
（六） Spark的Transformation和action介绍
zhtzh312的博客
07-11 648
RDD支持两种类型的操作：Transformation（从现有的数据集创建新的数据集）和action（在对数据集运行计算后将值返回给驱动程序）。例如，map是一种Transformation，它通过一个函数来传递每个数据集元素，并返回一个表示结果的新RDD。另一方面，reduce是一个action，它使用某个函数聚合RDD的所有元素，并将最终结果返回给driver驱动程序（尽管还有一...
Spark中的Transformations和Actions介绍
zhaoguowei的博客
10-28 1078
RDD提供了两种类型的操作：transformation和action 所有的transformation都是采用的懒策略，如果只是将transformation提交是不会执行计算的，计算只有在action被提交的时候才被触发。 action操作：action是得到一个值，或者一个结果（直接将RDD cache到内存中） 常见的转换操作有 Transformation 算子 含义 ...
Spark07：【案例】Transformation和Action
weixin_40612128的博客
03-09 561
一、Transformation和Action 接下来我们详细分析一下Spark中对RDD的操作 Spark对RDD的操作可以整体分为两类： Transformation和Action 这里的Transformation可以翻译为转换，表示是针对RDD中数据的转换操作，主要会针对已有的RDD创建一个新的RDD：常见的有map、flatMap、filter等等。 Action可以翻译为执行，表示是触发任务执行的操作，主要对RDD进行最后的操作，比如遍历、reduce、保存到文件等，并且还可以把结果返回给Dri
Spark核心概念 – Transformation和Action
weixin_45383965的博客
10-12 164
• Transformation是懒操作，用于定义新的 RDD；而Action启动计算操作，并向用户程序返回值或向外部存储写数据。 Transformation有如下几种： map(f: T => U): RDD[T] => RDD [U] 转换格式 filter(f: T => Bool): RDD[T] => RDD[T] 过滤 flatMap(f: T =&gt...
Spark算子详解：Transformation与Action操作
"Spark算子的详细使用方法涵盖了Spark中的Transformation和Action两类算子，以及它们的细分类型，包括Value型、Key-Value型的Transformation算子和Action算子。核心概念是RDD（弹性分布式数据集），它是Spark计算的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值