大数据——Spark RDD算子（十二）RDD分区操作mapPartitions、mapPartitionsWithIndex

最新推荐文章于 2022-03-27 21:17:30 发布
最新推荐文章于 2022-03-27 21:17:30 发布
阅读量483 收藏 4
点赞数
文章标签： spark 大数据 java scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsjia2970727/article/details/109643168
版权

Spark RDD算子（十二）RDD分区操作mapPartitions、mapPartitionsWithIndex

mapPartitions

  • mapPartitions可以倒过来理解，先partition，再把每个partition进行map函数
  • 适用场景

如果在映射的过程中需要频繁创建额外的对象，使用mapPartitions要比map高效的多
比如，将RDD中的所有数据通过JDBC连接写入数据库，如果使用map函数，可能要为每一个元素都创建一个connection，这样开销很大。如果使用mapPartitions，那么只需要针对每一个分区建立一个connection

把每一个元素变成map(i,i*i)

Scala版本

package nj.zb.sparkstu

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

object mapPartitions {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("mapPartitions")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6,7,8,9,10))
    def fun(iter:Iterator[Int]):Iterator[(Int,Int)]={
      var res=List[(Int,Int)]()
      while (iter.hasNext){
        val cur: Int = iter.next
        res=res.::(cur,cur*cur)
      }
      res.iterator
    }

    val rdd2: RDD[(Int, Int)] = rdd1.mapPartitions(fun)
    rdd2.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

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

public class mapPartitionsJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

		JavaRDD<Tuple2<Integer, Integer>> tuple2JavaRDD = rdd1.mapPartitions(new FlatMapFunction<Iterator<Integer>, Tuple2<Integer, Integer>>() {
			@Override
			public Iterator<Tuple2<Integer, Integer>> call(Iterator<Integer> it) throws Exception {
				ArrayList<Tuple2<Integer, Integer>> tuple2s = new ArrayList<>();
				while (it.hasNext()) {
					Integer next = it.next();
					tuple2s.add(new Tuple2<Integer, Integer>(next, next * next));
				}
				return (Iterator<Tuple2<Integer, Integer>>) tuple2s;
			}
		});
		tuple2JavaRDD.foreach(new VoidFunction<Tuple2<Integer, Integer>>() {
			@Override
			public void call(Tuple2<Integer, Integer> tp2) throws Exception {
				System.out.println(tp2);
			}
		});
	}
}

把(i,j) 变成(i,j*j)

Scala版本

package nj.zb.sparkstu

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



object mapPartitions2 {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[(Int, Int)] = sc.parallelize(List((1,1),(1,2),(1,3),(2,1),(2,2),(2,3)))

    def fun(iter:Iterator[(Int,Int)]):Iterator[(Int,Int)]={
      var res = List[(Int, Int)]()
      while (iter.hasNext){
        val cur= iter.next
       res=res.::(cur._1,cur._2*cur._2)
      }
      res.iterator
    }

    val rdd2: RDD[(Int, Int)] = rdd1.mapPartitions(fun)
    rdd2.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

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.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

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

public class mapPartitions2Java {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Tuple2<Integer, Integer>> rdd1 = sc.parallelize(Arrays.asList(
				new Tuple2<Integer, Integer>(1, 1),
				new Tuple2<Integer, Integer>(1, 2),
				new Tuple2<Integer, Integer>(1, 3),
				new Tuple2<Integer, Integer>(2, 1),
				new Tuple2<Integer, Integer>(2, 2),
				new Tuple2<Integer, Integer>(2, 3)));

		JavaPairRDD<Integer, Integer> rdd2 = JavaPairRDD.fromJavaRDD(rdd1);

		JavaRDD<Tuple2<Integer, Integer>> rdd3 = rdd2.mapPartitions(new FlatMapFunction<Iterator<Tuple2<Integer, Integer>>, Tuple2<Integer, Integer>>() {
			@Override
			public Iterator<Tuple2<Integer, Integer>> call(Iterator<Tuple2<Integer, Integer>> tuple2Iterator) throws Exception {
				ArrayList<Tuple2<Integer, Integer>> tuple2s = new ArrayList<>();
				while (tuple2Iterator.hasNext()) {
					Tuple2<Integer, Integer> next = tuple2Iterator.next();
					tuple2s.add(new Tuple2<Integer, Integer>(next._1, next._2 * next._2));
				}
				return (Iterator<Tuple2<Integer, Integer>>) tuple2s;
			}
		});
		rdd3.foreach(new VoidFunction<Tuple2<Integer, Integer>>() {
			@Override
			public void call(Tuple2<Integer, Integer> integerIntegerTuple2) throws Exception {
				System.out.println(integerIntegerTuple2);
			}
		});
	}
}

把每一个元素平方

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.VoidFunction;

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

public class mapPartitions3Java {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
		JavaRDD<Integer> rdd2 = rdd1.mapPartitions(new FlatMapFunction<Iterator<Integer>, Integer>() {
			@Override
			public Iterator<Integer> call(Iterator<Integer> integerIterator) throws Exception {
				ArrayList<Integer> results = new ArrayList<>();
				while (integerIterator.hasNext()) {
					Integer i = integerIterator.next();
					results.add(i * i);
				}
				for (Integer a :
						results) {
					System.out.println(a);
				}
				return (Iterator<Integer>) results;
			}
		});
		rdd2.foreach(new VoidFunction<Integer>() {
			@Override
			public void call(Integer integer) throws Exception {
				System.out.println(integer);
			}
		});
	}
}

mapPartitionsWithIndex

  • 与mapPartitions类似，也是按照分区进行的map操作，不过mapPartitionsWithIndex传入的参数多个一个分区的值

统计各个分区中的元素

Scala版本

package nj.zb.kb09.gaoji

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

object mapPartitionsWithIndex {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsWithIndex")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5,6,7,8,9,10))

    def fun(i:Int,iter:Iterator[Int]):Iterator[(Int,Int)]={
      var res = List[(Int,Int)]()
      while(iter.hasNext){
        val next = iter.next()
        res=res.::(i,next)
      }
      res.iterator
    }

    val rdd2: RDD[(Int, Int)] = rdd1.mapPartitionsWithIndex(fun)
    rdd2.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

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

public class mapPartitionsWithIndex {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsWithIndexJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

		JavaRDD<Tuple2<Integer, Integer>> tuple2JavaRDD = rdd1.mapPartitionsWithIndex(new Function2<Integer, Iterator<Integer>, Iterator<Tuple2<Integer, Integer>>>() {
			@Override
			public Iterator<Tuple2<Integer, Integer>> call(Integer partIndex, Iterator<Integer> it) throws Exception {
				ArrayList<Tuple2<Integer, Integer>> tuple2s = new ArrayList<>();
				while (it.hasNext()) {
					int next = it.next();
					tuple2s.add(new Tuple2<>(partIndex, next));
				}
				return tuple2s.iterator();
			}
		}, false);

		tuple2JavaRDD.foreach(new VoidFunction<Tuple2<Integer, Integer>>() {
			@Override
			public void call(Tuple2<Integer, Integer> tp2) throws Exception {
				System.out.println(tp2);
			}
		});
	}
}

结果展示：在这里插入图片描述

统计键值对中的各个分区的元素

Scala版本

package nj.zb.sparkstu

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

object mapPartitionsWithIndex2 {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsWithIndex")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[(Int, Int)] = sc.parallelize(List((1,1),(1,2),(2,3),(2,4),(3,5),(3,6),(4,7),(4,8),(5,9),(5,10)))

    def fun(i:Int,iter:Iterator[(Int,Int)]):Iterator[(Int, (Int, Int))]={
      var res = List[(Int,(Int,Int))]()
      while (iter.hasNext){
        var next = iter.next()
        res=res.::(i,next)
      }
      res.iterator
    }
    val rdd2: RDD[(Int, (Int, Int))] = rdd1.mapPartitionsWithIndex(fun)
    rdd2.collect.foreach(println)
  }
}

结果展示：在这里插入图片描述

Java版本

package nj.zb.sparkstu;

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.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

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

public class mapPartitionsWithIndex2Java {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("mapPartitionsWithIndex");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Tuple2<Integer, Integer>> rdd = sc.parallelize(Arrays.asList(new Tuple2<Integer, Integer>(1, 1), new Tuple2<Integer, Integer>(1, 2)
				, new Tuple2<Integer, Integer>(2, 3), new Tuple2<Integer, Integer>(2, 4)
				, new Tuple2<Integer, Integer>(3, 5), new Tuple2<Integer, Integer>(3, 6)
				, new Tuple2<Integer, Integer>(4, 7), new Tuple2<Integer, Integer>(4, 8)
				, new Tuple2<Integer, Integer>(5, 9), new Tuple2<Integer, Integer>(5, 10)
		), 3);
		JavaPairRDD<Integer, Integer> pairRDD = JavaPairRDD.fromJavaRDD(rdd);

		JavaRDD<Tuple2<Integer, Tuple2<Integer, Integer>>> mapPartitionIndexRDD = pairRDD.mapPartitionsWithIndex(new Function2<Integer, Iterator<Tuple2<Integer, Integer>>, Iterator<Tuple2<Integer, Tuple2<Integer, Integer>>>>() {
			@Override
			public Iterator<Tuple2<Integer, Tuple2<Integer, Integer>>> call(Integer partIndex, Iterator<Tuple2<Integer, Integer>> tuple2Iterator) {
				ArrayList<Tuple2<Integer, Tuple2<Integer, Integer>>> tuple2s = new ArrayList<>();

				while (tuple2Iterator.hasNext()) {
					Tuple2<Integer, Integer> next = tuple2Iterator.next();
					tuple2s.add(new Tuple2<Integer, Tuple2<Integer, Integer>>(partIndex, next));
				}
				return tuple2s.iterator();
			}
		}, false);

		mapPartitionIndexRDD.foreach(new VoidFunction<Tuple2<Integer, Tuple2<Integer, Integer>>>() {
			@Override
			public void call(Tuple2<Integer, Tuple2<Integer, Integer>> integerTuple2Tuple2) throws Exception {
				System.out.println(integerTuple2Tuple2);
			}
		});
	}
}

结果展示：在这里插入图片描述

补充：打印各个分区的操作，可以使用glom方法

package nj.zb.sparkstu;

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.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

import java.util.Arrays;
import java.util.List;

public class glom {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("glom");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Tuple2<Integer, Integer>> rdd1 = sc.parallelize(Arrays.asList(new Tuple2<Integer, Integer>(1, 1), new Tuple2<Integer, Integer>(1, 2)
				, new Tuple2<Integer, Integer>(2, 3), new Tuple2<Integer, Integer>(2, 4)
				, new Tuple2<Integer, Integer>(3, 5), new Tuple2<Integer, Integer>(3, 6)
				, new Tuple2<Integer, Integer>(4, 7), new Tuple2<Integer, Integer>(4, 8)
				, new Tuple2<Integer, Integer>(5, 9), new Tuple2<Integer, Integer>(5, 10)));
		JavaPairRDD<Integer, Integer> pairRDD = JavaPairRDD.fromJavaRDD(rdd1);
		/*补充：打印各个分区的操作，可以使用 glom 的方法*/
		System.out.println("打印各个分区的操作，可以使用 glom 的方法");
		JavaRDD<List<Tuple2<Integer, Integer>>> glom = pairRDD.glom();
		glom.foreach(new VoidFunction<List<Tuple2<Integer, Integer>>>() {
			@Override
			public void call(List<Tuple2<Integer, Integer>> tuple2s) throws Exception {
				System.out.println(tuple2s);
			}
		});
	}
}

结果展示：
在这里插入图片描述

蜂蜜柚子加苦茶
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark中mapPartitionsWithIndex算子详解介绍
CSDN 精品推荐
08-16 294
上一节中我们讲到如何使用 `mapPartitions` 来操作每个分区的数据，但是有些需求里面要求我们对待每个分区的处理逻辑不一样，不同的分区可能执行不同的操作，由于 `mapPartitions` 不能获取当前处理的分区是哪个分区，所以无法用它来实现要求功能。
Spark创建RDD、DataFrame各种情况的默认分区数
01-27
熟悉Spark的分区对于Spark性能调优很重要，本文总结Spark通过各种函数创建RDD、DataFrame时默认的分区数，其中主要和sc.defaultParallelism、sc.defaultMinPartitions以及HDFS文件的Block数量有关，还有很坑的某些...
spark MapPartitionsRDD及ShuffleRDD
鸭梨的博客
11-20 1389
private[spark] class MapPartitionsRDD[U: ClassTag, T: ClassTag]( var prev: RDD[T], f: (TaskContext, Int, Iterator[T]) => Iterator[U], // (TaskContext, partition index, iterator) preservesPartitioning: Boolean = false, isOrderSensitive:
Spark高级算子：mapPartitionsWithIndex，aggregate，aggregateByKey
yilulvxing的博客
08-17 6936
1：mapPartitionsWithIndex： 对RDD中的每个分区（带有下标）进行操作，通过自己定义的一个函数来处理 API文档： def mapPartitionsWithIndex[U](f: (Int, Iterator[T]) => Iterator[U]) def mapPartitions[U](f: (Iterator[T]) ...
[Spark精进]必须掌握的4个RDD算子之mapPartitions算子
Maynor的博客
09-24 993
文章目录返回第一章第二个mapPartitions：以数据分区为粒度的数据转换点击跳转到下一讲 返回第一章 第二个mapPartitions：以数据分区为粒度的数据转换 按照介绍算子的惯例，我们还是先来说说 mapPartitions 的用法。mapPartitions，顾名思义，就是以数据分区为粒度，使用映射函数 f 对 RDD 进行数据转换。对于上述单词哈希值计数的例子，我们结合后面的代码，来看看如何使用 mapPartitions 来改善执行性能： // 把普通RDD转换为Paired RDD
[spark]Spark算子：RDD基本转换操作(5)–mapPartitions、mapPartitionsWithIndex
11-25 1523
mapPartitions def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U]): RDD[U] 该函数和map函数类似，只不过映射函数的参数由RDD中的每一个元素变成了RDD中每一个分区的迭代器。
加米谷大数据——Spark核心技术原理透视Spark运行原理.docx
10-15
Spark是一种分布式计算框架，以其高效、易用和统一的数据处理能力在大数据领域备受推崇。Spark的核心技术原理包括了对数据的处理方式、运行流程和架构设计等多个方面。以下是对这些知识点的详细解释： 1. **Spark ...
大数据实验报告Windows环境下安装Spark及RDD编程和Spark编程实现wordcount.doc
12-15
大数据实验报告 Windows 环境下安装 Spark 及 RDD 编程和 Spark 编程实现 wordcount 本实验报告主要介绍了在 Windows 环境下安装 Spark 及 RDD 编程和 Spark 编程实现 wordcount 的步骤和过程。实验中首先安装了 ...
大数据spark学习之rdd概述
05-03
在 Spark 中，对数据的所有操作不外乎创建 RDD、转化已有RDD 以及调用 RDD 操作进行求值。每个 RDD 都被分为多个分区，这些分区运行在集群中的不同节点上。RDD 可以包含 Python、Java、Scala 中任意类型的对象， ...
【RDD编程】map和mapPartitions
这个人很蓝
08-01 858
map和mapPartitions map针对RDD中的每一个元素调用一次函数，而mapPartitions针对RDD中每个Partition调用一次函数，假设RDD有N个元素，有M个分区，那么map的函数的将被调用N次，而mapPartitions被调用M次。，因此在编写map和mapPartitions的函数时需要有一个概念，map传入的是RDD的一个元素，而mapPartitions传入的是RDD的一个分区。 如下可见mapFun和mappartitionFun的区别 def mapFun(x):
scala MapPartitionsRDD输出问题
只想买把蝴蝶knife
03-16 1020
在使用scala的时候能够对MapPartitionRDD类型进行调试，但是在调试的时候不能直接表示这个结构.调试界面像这个样子. 对于这种类型的数据可以使用下面的数据进行输出调试 MapPartitionRDD.collect().foreach(println) 输出如下: ((14816,302217),3.3482833068031983) ((14816,155001),3.624928637634981) ((14816,184282),3.6818899102059124) ((14816,
Spark框架——RDD算子mapPartitions迭代器(基于Scala语言)
那人独钓寒江雪
03-27 5557
/*mapPartitions 和map算子是一样的,只不过map是针对每一条数据进行转换,mapPartitions 针对一整个分区的数据进行转换 1.map的func的参数是单条数据,mapPartitions的fnc的参数是一个集合(一个分区中的整个所有的数据) 2.map的func返回值也是单条数据,mapPartitions返回值是一个集合 */ //collect一般都在定义的函数外面收集 class TransformationOp { val conf: SparkConf =ne
Spark中mapPartitions使用
热门推荐
心如止水 宠辱不惊
06-05 2万+
转：http://blog.csdn.net/lsshlsw/article/details/48627737 与map方法类似，map是对rdd中的每一个元素进行操作，而mapPartitions(foreachPartition)则是对rdd中的每个分区的迭代器进行操作。如果在map过程中需要频繁创建额外的对象(例如将rdd中的数据通过jdbc写入数据库,map需要为每个元素创建一个
Spark RDD 常用算子
weixin_34067049的博客
12-20 198
2019独角兽企业重金招聘Python工程师标准>>> ...
[大数据之Spark]——Transformations转换入门经典实例
xingoo
10-09 162
[大数据之Spark]——Transformations转换入门经典实例 Spark相比于Mapreduce的一大优势就是提供了很多的方法，可以直接使用；另一个优势就是执行速度快，这要得益于DAG的调度，想要理解这个调度规则，还要理解函数之间的依赖关系。 本篇就着重描述下Spark提供的Transformations方法. 依赖关系 宽依赖和窄...
Spark算子：RDD基本转换操作(5)–mapPartitions、mapPartitionsWithIndex
houzhizhen的专栏
01-24 2367
关键字：Spark算子、Spark RDD基本转换、mapPartitions、mapPartitionsWithIndex mapPartitions def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean = false)(implicit arg0: ClassTag[U])
spark RDD基础装换操作--mapPartitionsWithIndex操作
weixin_43744732的博客
01-29 376
6.mapPartitionsWithIndex操作 将RDD中所有考试分数高于95分的“学生准考证号”,“对应分数” 和“当前数据所在分区”拼接后输出。 scala> val rddData =sc.parallelize(Array(("20180001",83),("201800002",97),("20180003",100),("20180004",95),("20180005",...
spark 的transformations之map，flatMap，mapPartitions,mapPartitionsWithIndex的用法
刘光华的专栏
09-23 3623
版本spark1.6.1       spark的编程思想跟mapreduce有很大的相似之处，这几个函数都可以看做是类似在map端的操作处理。       一个RDD（分布式弹性数据集），包含n个partition，你可以将每个partition看做是类似map的操作。   Transformation Meaning map(func) Return a new distributed
Spark的map，mapPartitions，mapPartitionsWithIndex详解
QQ1131221088的博客
01-20 2671
原理解读 spark的官网给的函数定义，如下，可以仔细读一读，理解一下之间的差异。 Transformation Meaning map(func) Return a new distributed dataset formed by passing each element of the source through a function func. mapPartition...
sparkrdd算子
最新发布
03-18
Spark RDD（弹性分布式数据集）是Spark中最基本的数据抽象，它代表了一个不可变、可分区、可并行计算的数据集合。RDD提供了一系列的算子（操作符）来进行数据的转换和计算。下面是一些常用的Spark RDD算子介绍： 1....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值