大数据——Spark RDD算子（九）基本的Action（动作）算子first、take、collect、count、countByValue、reduce、aggregate、fold、top

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

Spark RDD算子（九）基本的Action（动作）算子first、take、collect、count、countByValue、reduce、aggregate、fold、top

first

  • 返回RDD中第一个元素

Scala版本

package nj.zb.sparkstu

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

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

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

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 java.util.Arrays;

public class firstJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("firstJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		Integer rdd2 = rdd1.first();
		System.out.println(rdd2);
	}
}

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

take

  • 返回rdd.take(n)中前n个元素

Scala版本

package nj.zb.sparkstu

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

object take {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("takeScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    val rdd2: Array[Int] = rdd1.take(3)
    rdd2.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 java.util.Arrays;
import java.util.List;

public class takeJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("takeJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		List<Integer> rdd2 = rdd1.take(3);
		for (Integer a :
				rdd2) {
			System.out.println(a);
		}
	}
}

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

collect

  • 返回RDD中所有的元素

Scala版本

package nj.zb.sparkstu

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

object collect {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("collectScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    val rdd2: Array[Int] = rdd1.collect()
    rdd2.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 java.util.Arrays;
import java.util.List;

public class collectJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("collectJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		List<Integer> collect = rdd1.collect();
		for (Integer a :
				collect) {
			System.out.println(a);
		}
	}
}

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

count

  • 返回RDD中的元素的个数

Scala版本

package nj.zb.sparkstu

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

object count {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("countScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    val rdd2: Long = rdd1.count()
    println(rdd2)
  }
}

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

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 java.util.Arrays;


public class countJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("countJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		long rdd2 = rdd1.count();
		System.out.println(rdd2);
	}
}

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

countByValue

  • 各元素在RDD中出现的次数，返回{(key1,次数),(key2,次数),…(keyn,次数)}

Scala版本

package nj.zb.sparkstu

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

object countByValue {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("countByValueScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,3,4,4,5))
    val rdd2: collection.Map[Int, Long] = rdd1.countByValue()
    rdd2.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 java.util.Arrays;
import java.util.Map;
import java.util.Set;

public class countByValueJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("countByValueJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 3, 4, 4, 5));
		Map<Integer, Long> rdd2 = rdd1.countByValue();
		Set<Integer> rdd3 = rdd2.keySet();
		for (Integer a :
				rdd3) {
			System.out.println(a+":"+rdd2.get(a));
		}
	}
}

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

reduce

  • rdd.reduce(func)并行整合RDD中所有数据，类似于Scala中集合的reduce
// An highlighted block
var foo = 'bar';

Scala版本

package nj.zb.sparkstu

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

object reduce {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("reduceScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4))
    val rdd2: Int = rdd1.reduce((x, y)=>x+y)
    println(rdd2)
  }
}

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

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 java.util.Arrays;

public class reduceJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("reduceJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4));
		Integer rdd2 = rdd1.reduce(new Function2<Integer, Integer, Integer>() {
			@Override
			public Integer call(Integer v1, Integer v2) throws Exception {
				return v1 + v2;
			}
		});
		System.out.println(rdd2);
	}
}

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

aggregate

  • 和reduce()相似，但是通常返回不同类型的函数，一般不用这个函数

Scala版本

package nj.zb.sparkstu

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

object a {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[1]").setAppName("a")
    val sc = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    def fun1(x:Int,y:Int):Int={
      val s = "com_exp = %d + %d"
      println(s.format(x, y))
      x+y
    }
    def fun2(x:Int,y:Int):Int={
      val s = "com_exp = %d + %d"
      println(s.format(x, y))
      x+y
    }
    val rdd2: Int = rdd1.aggregate(5)(fun1,fun2)
    println(rdd2)
  }
}

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

fold

  • rdd.fold(num)(fun)一般不用这个函数
  • 和reduce()一样，但是提供了初始值num，每个元素计算时，先要和这个初始值进行折叠，注意，这里会按照每个分区进行fold，然后分区之间还会再次进行fold

Scala版本

package nj.zb.sparkstu

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

object fold {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[1]").setAppName("foldScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4))
    def seqno(m: Int, n: Int): Int = {
      val s = "seq_exp = %d + %d"
      println(s.format(m, n))
      m + n
    }
    val rdd2: Int = rdd1.fold(5)(seqno)
    println(rdd2)
  }
}

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

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 java.util.Arrays;

public class foldJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[1]").setAppName("foldJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4));
		Integer rdd2 = rdd1.fold(5, new Function2<Integer, Integer, Integer>() {
			@Override
			public Integer call(Integer v1, Integer v2) throws Exception {
				return v1 + v2;
			}
		});
		System.out.println(rdd2);
	}
}

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

top

  • rdd.top(n)按照降序或指定的排序规则（默认是倒序），返回前n个元素

Scala版本

package nj.zb.sparkstu

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

object top {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("topScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    val rdd2: Array[Int] = rdd1.top(3)
    rdd2.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 java.util.Arrays;
import java.util.List;

public class topJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("topJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		List<Integer> rdd2 = rdd1.top(3);
		for (Integer a :
				rdd2) {
			System.out.println(a);
		}
		System.out.println(rdd2);
	}
}

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

takeOrdered

  • rdd.take(n)
  • 对RDD元素进行升序排序，取出前n个元素并返回，也可以自定义比较器（这里不介绍），类似于top的相反的方法

Scala版本

package nj.zb.sparkstu

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

object takeOrdered {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("takeOrderedScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4))
    val rdd2: Array[Int] = rdd1.takeOrdered(3)
    rdd2.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 java.util.Arrays;
import java.util.List;

public class takeOrderedJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("takeOrderedJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1= sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		List<Integer> rdd2 = rdd1.takeOrdered(3);
		for (Integer a :
				rdd2) {
			System.out.println(a);
		}
	}
}

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

foreach

  • 对RDD中的每个元素使用给定的函数

Scala版本

package nj.zb.sparkstu

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

object foreach {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("foreachScala")
    val sc: SparkContext = new SparkContext(conf)
    val rdd1: RDD[Int] = sc.parallelize(List(1,2,3,4,5))
    val rdd2: Array[Int] = rdd1.takeOrdered(3)
   rdd2.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.VoidFunction;

import java.util.Arrays;

public class foreachJava {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("foreachJava");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<Integer> rdd1 = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5));
		rdd1.foreach(new VoidFunction<Integer>() {
			@Override
			public void call(Integer integer) throws Exception {
				System.out.println(integer);
			}
		});
	}
}

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

蜂蜜柚子加苦茶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark算子：RDD行动Action操作–aggregate、fold、lookup；reduce/fold/aggregate区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-25 347
关键字：Spark算子、Spark函数、Spark RDD行动Action、aggregate、fold、lookup aggregate def aggregate[U](zeroValue: U)(seqOp: (U, T) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U aggregate用户聚合RDD中的元素，先使用seqOp将RDD中每个分区中的T类型元素聚合成U类型，再使用combOp将之前每个分区聚合后的U类型聚合成U类型，
SparkRDD——行动算子
tyh1579152915的博客
06-10 3517
一、行动算子定义 spark的算子可以分为trans action算子 以及 action算子 ，即变换/转换 算子。如果执行一个RDD算子并不触发作业的提交，仅仅只是记录作业中间处理过程，那么这就是trans action算子 ，相反如果执行这个 RDD 时会触发 Spark Context 提交 Job 作业，那么它就是 action算子及行动算子。 总结来说就是在Spark中，转换算子并不会马上进行运算的，即所谓的“惰性运算”，而是在遇到行动算子时才会执行相应的语句的，触发Spark的任务调度并开始进
Spark常用动作算子 first、take、collect、count、countByValue、reduce、aggregate、fold、takeOrdered（java和scala版本）
xiaoxionghanhan的博客
11-09 634
scala版本 import org.apache.spark.{SparkConf, SparkContext} object ActionRDDScala { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("actionRDD").setMaster("local[2]") val sc = new SparkContext(conf) val rdd = sc.
Spark常用的action算子
weixin_34187822的博客
12-29 907
action算子简介 Action类算子也是一类算子（函数）叫做行动算子，如foreach,collect，count等。Transformations类算子是延迟执行，Action类算子是触发执行。一个application应用程序（就是我们编写的一个应用程序）中有几个Action类算子执行，就有几个job运行。 1.reduce 通过函数func聚集数据集中的所有元素，这个函数必须是关联性的，...
大数据相关概念-什么是算子
热门推荐
第一高度的专栏 - 祝愿大家坚持学习，持续进步，最终实现理想！
11-09 2万+
  在流处理、交互式查询中有个常用的概念是“算子”，在英文中被成为“Operation”，在数学上可以解释为一个函数空间到函数空间上的映射O：X-&gt;X，其实就是一个处理单元，往往是指一个函数，在使用算子时往往会有输入和输出，算子则完成相应数据的转化，比如：Group、Sort等都是算子。       关注以下公众号“程序员的足迹”，免费下载高质量相关资料 ...
Action行动算子
LssTwl的博客
01-25 735
Action行动算子 概念：Action类算子也是一类算子（函数）叫做行动算子，如foreach,collect，count等。Transformations类算子是延迟执行，Action类算子是触发执行。一个application应用程序中有几个Action类算子执行，就有几个job运行 常用算子: count: 返回数据集中的元素数。会在结果计算完成后回收到Driver端 t...
Spark算子：RDD常用的10种action算子 & 3种常见保存路径
攻城狮Kevin
02-18 1416
目录 1. reduce（func） 2. collect（） 3. count（） 4. first（） 5. take（n） 6. takeOrdered（n） 7. aggregate（） 8. fold（num）（func） 9. 三种常用RDD元素保存路径 10. countByKey 11. foreach（func）、foreachPartition（func）...
spark RDD算子（九）之基本的Action操作 first, take, collect, count, countByValue, reduce, aggregate, fold,top
qianchun22的博客
11-10 534
章节目录一、firstScala版本Java版本二、takeScala版本Java版本三、collectScala版本Java版本四、countScala版本Java版本五、countByValueScala版本Java版本六、reduceScala版本Java版本七、aggregateScala版本八、foldScala版本Java版本九、topScala版本Java版本十、takeOrderedScala版本Java版本十一、foreachScala版本Java版本 一、first 返回第一个元素 Sc
RDD算子（九）基本的Action操作first、take、collec、count、countByValue、reduce、aggregate、fold、to
qq_40333693的博客
11-11 528
first 返回第一个元素 scala版本： val conf = new SparkConf().setAppName("First").setMaster("local[1]") val sc = new SparkContext(conf) val rdd = sc.parallelize(List(1, 2, 3, 3)) println(rdd.first()) java版本： SparkConf conf = new SparkConf().setMaster("local[1]").set
Spark之RDD动作算子（Action）大全
zp17834994071的博客
08-07 5196
前面已经给大家讲过RDD原理以及常用的转换算子，今天就再给大家说说RDD的动作算子有哪些，以便大家更能全面的理解和掌握。 对于动作算子来说，本质上动作算子是通过SparkContext执行提交作业操作，触发RDD DAG（有向无环图）的执行；所有的动作算子都是急迫型（non-lazy），RDD遇到Action就会立即计算。 常用动作算子 count 返回数据集中的元素的个数 案例： val rdd=sc.parallelize(List(1,2,3,4,5,6)) rdd.count //6 coll
SparkStreaming部分：updateStateByKey算子（包含从Linux端获取数据，flatmap切分，maptopair分类，写入到本地创建的文件夹中）【Java版纯代码】
wyqwilliam的博客
07-30 333
package com.bjsxt; import java.util.List; import org.apache.spark.SparkConf; import org.apache.spark.api.java.function.FlatMapFunction; import org.apache.spark.api.java.function.Function2; import o...
Spark 常见的transformation算子和action算子有哪些？
大数据流浪法师的学习笔记与分享
05-26 1316
Spark 常见的transformation算子和action算子有哪些？ transformation算子 map flatMap filter groupByKey reduceByKey sortByKey action算子 reduce collect first take aggregate countByKey foreach saveAsTextFile
Spark之Action算子（一）
夜阑听风
03-05 1万+
Spark算子分为两大类，本文介绍Action类算子。（1）reduce算子按照官网的解释，传入的参数是一个函数，一个双参数，返回值唯一的函数，建议，该函数是可交换的，是可联合的，如此，才能实现正确的并行计算。这里的函数，我平时用过加法操作，最大值操作，最小值操作；记得大数据里提过这个概念，诸如此类可以合并操作的函数，是最合适的，平均值类的，就不适用于此种操作了。如上图，使用并行化产生了一个算子，...
大数据学习-Flink（算子）
weixin_45126258的博客
02-28 1418
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录基本转换算子mapflatMapFilterKeyedStreamKeyBy多流转换算子SplitSelectConnectCoMap&CoFlatMapUnion 基本转换算子 map 数据进来一个处理一个 val streamMap = stream.map { x => x * 2 } flatMap 来一个数据后应用后将数据打散可以有多个输出，一个输入对应多条输出记录 val streamFlatMap
大数据技术之spark算子
最新发布
weixin_53191998的博客
03-10 380
大数据spark核心--算子
Spark RDD中两种算子之一：常见Action算子小结
weixin_44319333的博客
03-26 4461
常见Action算子： reduce(func)：通过函数func聚集集合中的所有的元素。func函数接收2个参数，返回一个值。这个函数必须是关联性的，确保可以被正确地并发执行。这个算子不像reduceByKey一样通过key进行分组，所以其是一个全量的操作。 collect()：在Driver的程序中，以数组的形式，返回数据集的所有元素。但是，请注意，这个只能在返回一个较小的数据子集时才能使用...
算子
weixin_43042467的博客
07-01 1626
算子：是一个函数空间到函数空间上的映射O：X→X。广义上的算子可以推广到任何空间，如内积空间等。 应用领域：数理科学 别 称：算符 外文名 ：operator 应用领域：数理科学 算子解释 广义的算子， 对任何函数进行某一项操作都可以认为是一个算子，甚至包括求幂次，开方都可以认为是一个算子，只是有的算子我们用了一个符号来代替他所要进行的运算罢了，所以大家看到算子就不要纠结，他和 f（x） 的 f 没区别，它甚至和加减乘除的基本运算符号都没有区别，只是他可以对单对象操作罢了(有的符号比如.
Action的常用算子count(),task(),countByKey(),collect()....
weixin_41244495的博客
08-04 906
action的常用算子         1.reduce();                  // 首先将第一个和第二个元素，传入call()方法，进行计算，会获取一个结果，比如1 + 2 = 3         // 接着将该结果与下一个元素传入call()方法，进行计算，比如3 + 3 = 6         //这个是它实现的Function2&lt;Integer, Integer,...
大数据（8e）RDD常用算子
ArYe
05-31 331
发出火花的目录0、概述1、转换算子（Transformations）1.1、分区内元素汇聚成数组：glom1.2、两个RDD运算2、行动算子（Actions）2.1、collect2.2、reduce、take、sum、countByValue 0、概述 RDD算子：RDD里面实现的方法 包括转换算子和行动算子 1、转换算子（Transformations） 转换算子执行后，会返回新RDD，但不会立即执行计算（惰性加载） 方法名(参数) 说明 map(func) 将源RDD的每个元素
Spark RDD 算子详解：实现原理与执行流程分析
RDD 算子是 Spark 中的一种基本操作单元，用于处理和转换 RDD 数据。下面是 Spark 1.4.1 中一些常用的 RDD 算子和它们的实现原理。 1. take(num: Int)：take 算子用于从 RDD 中取出指定数量的元素。其实现原理是，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值