在spark中属于action算子的有什么 spark action算子

转载

mob64ca140ac564 2023-12-12 12:55:30

文章标签 System ide 数据库连接 文章分类 Spark 大数据

算子：

完整的spark代码执行下来叫做一个application，有多个job
个数与action算子相同。

action触发流程:
RDD-->RDD-->RDD-->RDD,不持久化情况下，每次action触发都会从头计算

具体的算子

算子分为两类，action算子与transformation算子，持久化算子属于transformation算子

action算子不会返回RDD,transformation总是返回RDD。

transfoamation：懒执行，只有当action算子出现才会执行，否则不执行。

1.很重要的：

mapToPair，map
reduceByKey
foreach，
而mapPartitions,foreachPartition：按分区计算（功能上可替代单个的foreach,map，性能高，原因不详

2.持久化的算子

cache:存于内存
 persist:可指定存于内存，磁盘等， pereiet()=cache();
 checkpoint:存于磁盘，用于RDD的切断（persist不行），比如丢失后的恢复，比如说RDD4丢了他要从
 头计算开始恢复，但是如果发现它对RDD3进行checkpoint了那么直接RDD3开始恢复 ，不同于前两项，
 application结束后不会被删除。可以checkpoint前对相应的RDDcache一下

3.类似于数据库操作

join,leftjoin,rightjoin,fullOuterJoin，,intersection计算交集,subtract，,union：都是两个RDD之间的操作，
cogroup,
distinct

注意：连接操作需要kv形式的RDD,计算交差集不一定要kv形式元素相同即可，union产生的RDD分区数等于两个父亲RDD之和,
而连接产生的RDD分区数等于调用该方法的父RDD的分区数
产生的RDD的元素数量join<joinleft,right<full

在spark中属于action算子的有什么 spark action算子_System

4.其他一些：

count
返回数据集中的元素数。会在结果计算完成后回收到Driver端。
take(n)
返回一个包含数据集前n个元素的集合。
first
first=take(1),返回数据集中的第一个元素。
foreach
循环遍历数据集中的每个元素，运行相应的逻辑。
collect
将计算结果回收到Driver端。

下面是3中的算子的代码示范：

public class Day02 {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local").setAppName("test");
		JavaSparkContext sc = new JavaSparkContext(conf);
		JavaRDD<String> rdd = sc.parallelize(Arrays.asList("a","a","b","b","b","c","d"));
		
		
		/**
		 * distinct
		 */
		JavaRDD<String> distinct = rdd.distinct();
		distinct.foreach(new VoidFunction<String>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public void call(String arg0) throws Exception {
				System.out.println(arg0);
			}
		});
		
		JavaPairRDD<String, Integer> mapToPair = rdd.mapToPair(new PairFunction<String, String, Integer>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<String, Integer> call(String s) throws Exception {
				// TODO Auto-generated method stub
				return new Tuple2<String, Integer>(s,1);
			}
		});
		JavaPairRDD<String, Integer> reduceByKey = mapToPair.reduceByKey(new Function2<Integer, Integer, Integer>() {
			
			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public Integer call(Integer v1, Integer v2) throws Exception {
				return v1*v2;
			}
		});
		JavaRDD<String> map = reduceByKey.map(new Function<Tuple2<String,Integer>, String>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public String call(Tuple2<String, Integer> tuple) throws Exception {
				return tuple._1;
			}
		});
		map.foreach(new VoidFunction<String>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public void call(String arg0) throws Exception {
				System.out.println(arg0);
			}
		});
		
		
		
		
		
		/**
		 * foreachPartition 一个分区一个分区的遍历数据，action算子
		 */
		rdd.foreachPartition(new VoidFunction<Iterator<String>>() {

			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public void call(Iterator<String> iter) throws Exception {
				List<String> list = new ArrayList<String>();
				
				System.out.println("创建数据库连接。。。。");
				
				while(iter.hasNext()) {
					String s = iter.next();
					System.out.println("拼接sql。。。。"+s);
					list.add(s);
				}
				
				System.out.println("关闭数据库连接。。。。");
			}
		});
		
		/**
		 * foreach 一条条处理数据
		 */
		rdd.foreach(new VoidFunction<String>() {
			
			/**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
			public void call(String s) throws Exception {
				
				System.out.println("创建数据库连接。。。。");
				System.out.println("插入数据库连接。。。。"+s);
				System.out.println("关闭数据库连接。。。。");
			}
		});
		
		
		/**
		 * mapPartitions
		 */
//		JavaRDD<String> mapPartitions = rdd.mapPartitions(new FlatMapFunction<Iterator<String>, String>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public Iterable<String> call(Iterator<String> iter) throws Exception {
//				List<String> list = new ArrayList<String>();
//				
//				System.out.println("创建数据库连接。。。。");
//				
//				while(iter.hasNext()) {
//					String s = iter.next();
//					System.out.println("拼接sql。。。。"+s);
//					list.add(s);
//				}
//				
//				System.out.println("关闭数据库连接。。。。");
//				return list;
//			}
//		});
//		mapPartitions.collect();
		
		
		
//		JavaRDD<String> map = rdd.map(new Function<String, String>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public String call(String s) throws Exception {
//				
//				System.out.println("创建数据库连接。。。。");
//				System.out.println("插入数据库连接。。。。"+s);
//				System.out.println("关闭数据库连接。。。。");
//				
//				
//				return s+"~";
//			}
//		});
//		map.collect();
		
//		JavaPairRDD<String, String> rdd1 = sc.parallelizePairs(Arrays.asList(
//				new Tuple2<String,String>("zhangsan","a"),
//				new Tuple2<String,String>("zhangsan","aa"),
//				new Tuple2<String,String>("zhangsan","aaa"),
//				new Tuple2<String,String>("lisi","b"),
//				new Tuple2<String,String>("lisi","bb"),
//				new Tuple2<String,String>("wangwu","c")
//				));
//		JavaPairRDD<String, String> rdd2 = sc.parallelizePairs(Arrays.asList(
//				new Tuple2<String,String>("zhangsan","10000"),
//				new Tuple2<String,String>("lisi","1"),
//				new Tuple2<String,String>("lisi","10"),
//				new Tuple2<String,String>("lisi","1000"),
//				new Tuple2<String,String>("wangwu","3"),
//				new Tuple2<String,String>("wangwu","30"),
//				new Tuple2<String,String>("maliu","200")
//				));
		/**
		 * cogroup 将两个RDD的key合并，每个RDD中的key对应一个value集合
		 */
//		JavaPairRDD<String, Tuple2<Iterable<String>, Iterable<String>>> cogroup = rdd1.cogroup(rdd2);
//		cogroup.foreach(new VoidFunction<Tuple2<String,Tuple2<Iterable<String>,Iterable<String>>>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, Tuple2<Iterable<String>, Iterable<String>>> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		
		
		/**
		 * subtract 取差集
		 */
//		JavaPairRDD<String, String> subtract = rdd2.subtract(rdd1);
//		
//		subtract.foreach(new VoidFunction<Tuple2<String,String>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, String> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		/**
		 * intersection 取交集
		 */
		
//		JavaPairRDD<String, String> intersection = rdd1.intersection(rdd2);
//		
//		intersection.foreach(new VoidFunction<Tuple2<String,String>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, String> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		
		
		
		
//		JavaPairRDD<String, Integer> rdd2 = sc.parallelizePairs(Arrays.asList(
//				new Tuple2<String,Integer>("zhangsan",100),
//				new Tuple2<String,Integer>("lisi",200),
//				new Tuple2<String,Integer>("wangwu",300),
//				new Tuple2<String,Integer>("tianqi",400)
//				),2);
//		JavaPairRDD<String, String> rdd3 = sc.parallelizePairs(Arrays.asList(
//				new Tuple2<String,String>("zhangsan1","100"),
//				new Tuple2<String,String>("lisi1","200"),
//				new Tuple2<String,String>("wangwu1","300"),
//				new Tuple2<String,String>("tianqi1","400")
//				),2);
		/**
		 * union 合并RDD， 类型一致
		 */
//		JavaPairRDD<String, String> union = rdd1.union(rdd3);
//		System.out.println("union partition legth = "+union.partitions().size());
//		
//		union.foreach(new VoidFunction<Tuple2<String,String>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, String> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		
		/**
		 * join
		 * 按照两个RDD的key去关联
		 * Join 后的RDD与父RDD分区多的那个分区数一致
		 */
//		JavaPairRDD<String, Tuple2<String, Integer>> joinRDD = rdd1.join(rdd2);
//		System.out.println("joinRDD partition legth = "+joinRDD.partitions().size());
//		joinRDD.foreach(new VoidFunction<Tuple2<String,Tuple2<String,Integer>>>() {
//			
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, Tuple2<String, Integer>> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		
		
		
		/**
		 * fullOuterJoin
		 */
//		JavaPairRDD<String, Tuple2<Optional<String>, Optional<Integer>>> fullOuterJoin = rdd1.fullOuterJoin(rdd2);
//		fullOuterJoin.foreach(new VoidFunction<Tuple2<String,Tuple2<Optional<String>,Optional<Integer>>>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, Tuple2<Optional<String>, Optional<Integer>>> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		/**
		 * rightOuterJoin
		 */
		
//		JavaPairRDD<String, Tuple2<Optional<String>, Integer>> rightOuterJoin = rdd1.rightOuterJoin(rdd2);
//		rightOuterJoin.foreach(new VoidFunction<Tuple2<String,Tuple2<Optional<String>,Integer>>>(
//				) {
//
//			/**
//					 * 
//					 */
//					private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, Tuple2<Optional<String>, Integer>> arg0) throws Exception {
//				System.out.println(arg0);
//			}
//		});
		
		/**
		 * leftOuterJoin
		 * 
		 */
//		JavaPairRDD<String, Tuple2<String, Optional<Integer>>> leftOuterJoin = rdd1.leftOuterJoin(rdd2);
//		leftOuterJoin.foreach(new VoidFunction<Tuple2<String,Tuple2<String,Optional<Integer>>>>() {
//
//			/**
//			 * 
//			 */
//			private static final long serialVersionUID = 1L;
//
//			@Override
//			public void call(Tuple2<String, Tuple2<String, Optional<Integer>>> tuple) throws Exception {
//				String key = tuple._1;
//				String value1 = tuple._2._1;
//				Optional<Integer> option = tuple._2._2;
//				if(option.isPresent()) {
//					
//					System.out.println("key = "+key +", value1 = "+value1+" ,value2 ="+option.get());
//				}else {
//					System.out.println("key = "+key +", value1 = "+value1+" ,value2 =Null");
//					
//				}
//			}
//		});
		
		
		sc.stop();
				
	}
}
*/

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。