Spark的RDD操作和描述_2

最新推荐文章于 2021-01-26 00:12:26 发布
最新推荐文章于 2021-01-26 00:12:26 发布
阅读量410 收藏
点赞数
文章标签： Spark RDD Spark 算子的优化 S
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/afafawfaf/article/details/81360085
版权

本次博客分发三大部分

一，Spark的RDD用JAVA的实现

二，Spark的RDD的说明

三，Spark的Scala的实现

1， Cartesian算子

1.1，Java代码实现

package com.lyl.it;

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

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 scala.Tuple2;

public class CartesianOperator {

	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setAppName("CartesianOperator").setMaster("local");

		JavaSparkContext sc = new JavaSparkContext(conf);
		List<String> words = Arrays.asList("A","B","C","D","F");
		List<String> numbers = Arrays.asList("1","2","3","4","5");
		JavaRDD<String> wordsRDD = sc.parallelize(words);
		JavaRDD<String> numberRDD = sc.parallelize(numbers);
		
		JavaPairRDD<String, String> pairs = wordsRDD.cartesian(numberRDD);
		for (Tuple2<String, String> pair:pairs.collect()) {
			System.out.println(pair);
		}
		
		sc.close();
	}
}

1.2，说明把对两个RDD的元素进行合并，下面是程序运行的结果

18/08/02 15:37:35 INFO DAGScheduler: Job 0 finished: collect at CartesianOperator.java:25, took 0.178710 s
(A,1)
(A,2)
(A,3)
(A,4)
(A,5)
(B,1)
(B,2)
(B,3)
(B,4)
(B,5)
(C,1)
(C,2)
(C,3)
(C,4)
(C,5)
(D,1)
(D,2)
(D,3)
(D,4)
(D,5)
(F,1)
(F,2)
(F,3)
(F,4)
(F,5)
18/08/02 15:37:35 INFO BlockManagerInfo: Removed broadcast_0_piece0 on localhost:54275 in memory (size: 1350.0 B, free: 1115.3 MB)

1.3，Scala的实现

package com.lyl.it

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object CartesianOperator {
  
       def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("CartesianOperator").setMaster("local")
        val sc = new SparkContext(conf)
        
        val words = Array("A","B","C","D","F")
        val numbers = Array("1","2","3","4","5")
        
        val wordsRDD = sc.parallelize(words)
        val numberRDD = sc.parallelize(numbers)
        
        val pairs = wordsRDD.cartesian(numberRDD)
        
        for( pairs <- pairs.collect() ){
          println(pairs)
         }
      }     
}

2， CogroupOperator算子 

2.1，Java代码实现

package com.lyl.it;

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

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

import scala.Tuple2;

public class CogroupOperator {
    
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setAppName("CogroupOperator").setMaster("local");
		JavaSparkContext sc = new JavaSparkContext(conf);
		
		@SuppressWarnings("unchecked")
		List<Tuple2<String, String>> studentList = Arrays.asList(
				new Tuple2<String, String>("1","A"),
				new Tuple2<String, String>("2","B"),
				new Tuple2<String, String>("1","C"),
				new Tuple2<String, String>("3","A"),
				new Tuple2<String, String>("1","F"),
				new Tuple2<String, String>("2","A")
				);
		
		@SuppressWarnings("unchecked")
		List<Tuple2<String, String>> sourcetList = Arrays.asList(
				new Tuple2<String, String>("1","100"),
				new Tuple2<String, String>("2","90"),
				new Tuple2<String, String>("1","80"),
				new Tuple2<String, String>("3","60"),
				new Tuple2<String, String>("1","50"),
				new Tuple2<String, String>("2","40")
				);
		
		JavaPairRDD<String, String> students = sc.parallelizePairs(studentList);
		JavaPairRDD<String, String> scores = sc.parallelizePairs(sourcetList);
		
		JavaPairRDD<String, Tuple2<Iterable<String>, Iterable<String>>>
		studentScores = students.cogroup(scores);
		
		studentScores.foreach(new VoidFunction<Tuple2<String,Tuple2<Iterable<String>,Iterable<String>>>>() {
			
			private static final long serialVersionUID = 1L;

			public void call(
					Tuple2<String, Tuple2<Iterable<String>, Iterable<String>>> tuple)
					throws Exception {
				System.out.println("student id: "+tuple._1);
				System.out.println("student name: "+tuple._2._1);
				System.out.println("student score: "+tuple._2._2);
			}
		});
		
		sc.close();
	}
}

2.2，说明获得分组元素，下面是程序运行的结果

18/08/02 15:44:23 INFO ShuffleBlockFetcherIterator: Started 0 remote fetches in 0 ms
student id: 2
student name: [B, A]
student score: [90, 40]
student id: 3
student name: [A]
student score: [60]
student id: 1
student name: [A, C, F]
student score: [100, 80, 50]
18/08/02 15:44:23 INFO Executor: Finished task 0.0 in stage 2.0 (TID 2). 1165 bytes result sent to driver

2.3，Scala的实现

package com.lyl.it

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object CogroupOperator {
       
      def main(args: Array[String]): Unit = {  
      val conf = new SparkConf().setAppName("CogroupOperator").setMaster("local")
      val sc = new SparkContext(conf)
      
      val studentList = Seq(("1","A"),("2","B"),("1","C"),("3","A"),("1","F"),("2","A"))
      val sourcetList = Seq(("1","100"),("2","90"),("1","80"),("3","60"),("1","50"),("2","40"))
      
      val students = sc.parallelize(studentList)
      val scores = sc.parallelize(sourcetList)
      students.cogroup(scores)
              .foreach{
               tuple => println("student id: "+tuple._1)
                        println("student name: "+tuple._2._1)
                        println("student score: "+tuple._2._2)
               }
      
      }
}

3， CollectOperator算子 

3.1，Java代码实现

package com.lyl.it;

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

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.Function;

public class CollectOperator {
	
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setAppName("CollectOperator").setMaster("local");
		JavaSparkContext sc = new JavaSparkContext(conf);
		
		List<Integer> numberList = Arrays.asList(1,2,3,4,5);
		JavaRDD<Integer> numbers = sc.parallelize(numberList);
		
		JavaRDD<Integer> doubleNumbers = numbers.map(new Function<Integer, Integer>() {

			private static final long serialVersionUID = 1L;

			public Integer call(Integer v) throws Exception {
				return v*2;
			}
		});
		
		List<Integer> doubleNumberList = doubleNumbers.collect();
		for (Integer num:doubleNumberList) {
			System.out.println(num);
		}
		
		sc.close();
	}
}

3.2，说明把数据汇到一个节点上，下面是程序运行的结果

18/08/02 15:47:05 INFO DAGScheduler: Job 0 finished: collect at CollectOperator.java:29, took 0.181348 s
2
4
6
8
10
18/08/02 15:47:05 INFO SparkUI: Stopped Spark web UI at http://192.168.158.1:4040
18/08/02 15:47:05 INFO MapOutputTrackerMasterEndpoint: MapOutputTrackerMasterEndpoint stopped!

3.3，Scala的实现

package com.lyl.it

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object CollectOperator {
  
     def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("CollectOperator").setMaster("local")
        val sc = new SparkContext(conf)
        val numberList = Array(1,2,3,4,5)
        val doubleNumbers = sc.parallelize(numberList)
                           .map(v => v*2)
                           .collect()
        for(num <- doubleNumbers){
          println(num)
        }
     }
}

4， CountByKey算子 

4.1，Java代码实现

package com.lyl.it;

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

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaSparkContext;

import scala.Tuple2;

public class CountByKeyOperator {
	
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setAppName("CountByKeyOperator").setMaster("local");
		JavaSparkContext sc = new JavaSparkContext(conf);
		
		@SuppressWarnings("unchecked")
		List<Tuple2<String, String>> scoreList = Arrays.asList(
				new Tuple2<String, String>("1","A"),
				new Tuple2<String, String>("2","A"),
				new Tuple2<String, String>("1","A"),
				new Tuple2<String, String>("3","A"),
				new Tuple2<String, String>("1","A"),
				new Tuple2<String, String>("2","A")
				);
		
		JavaPairRDD<String, String> students = sc.parallelizePairs(scoreList);
		
		Map<String, Object> counts = students.countByKey();
		
		for (Map.Entry<String, Object> studentCount:counts.entrySet()) {
			System.out.println(studentCount.getKey()+":"+studentCount.getValue());
		}
		
		sc.close();
	}
}

4.2，说明？？ 下面是程序运行的结果

18/08/02 15:51:26 INFO DAGScheduler: Job 0 finished: countByKey at CountByKeyOperator.java:31, took 0.268164 s
2:2
3:1
1:3
18/08/02 15:51:26 INFO SparkUI: Stopped Spark web UI at http://192.168.158.1:4040

4.3，Scala的实现

package com.lyl.it

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object CountByKeyOperator {
     
     def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("CollectOperator").setMaster("local")
        val sc = new SparkContext(conf)
        
        val scoreList = Seq(("1","A"),("2","A"),("1","A"),("3","A"),("1","A"),("2","A"))
        val counts = sc.parallelize(scoreList).countByKey()
        
        for(studentCount <- counts){
           println(studentCount)
        }
        
     }
}

5，Count算子 

5.1，Java代码实现

package com.lyl.it;

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

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;

public class CountOperator {

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

5.2，说明？？ 下面是程序运行的结果

18/08/02 15:57:52 INFO DAGScheduler: Job 0 finished: count at CountOperator.java:19, took 0.209459 s
5
18/08/02 15:57:52 INFO SparkUI: Stopped Spark web UI at http://192.168.158.1:4040
18/08/02 15:57:52 INFO MapOutputTrackerMasterEndpoint: MapOutputTrackerMasterEndpoint stopped!

5.3，Scala的实现

package com.lyl.it

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object CountOperator {
      
      def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("CountOperator").setMaster("local")
        val sc = new SparkContext(conf)
        val numberList = Array(1,2,3,4,5)
        val count = sc.parallelize(numberList).count()
        println(count)
        
      }
}

 

6，Dinstinct算子 

6.1，Java代码实现

6.2，说明？？ 下面是程序运行的结果

6.3，Scala的实现

 

IT影风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark中，RDD概述（五大属性，弹性介绍，5个特性）
fafa_1111的博客
06-27 8641
RDD特性
Spark的RDD的简要描述
weixin_44361667的博客
04-12 678
文章目录什么是RDDRDD的属性RDD特点RDD的两种算子缓存 什么是RDD RDD叫做弹性分布式数据集，是Spark中最基本的数据抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合。 RDD的属性 1)一组分区（Partition），即数据集的基本组成单位; 2)一个计算每个分区的函数; 3)RDD之间的依赖关系; 4)一个Partitioner，即RDD的分片函数;...
Spark RDD（2）
qq_33431394的博客
10-22 367
Spark core Insight 目标 深入理解 RDD 的内在逻辑 能够使用 RDD 的算子 理解 RDD 算子的 Shuffle 和缓存 理解 RDD 整体的使用流程 理解 RDD 的调度原理 理解 Spark 中常见的分布式变量共享方式 1. 深入 RDD 目标 深入理解 RDD 的内在逻辑, 以及 RDD 的内部属性(RDD 由什么组成) 1.1. 案例 需求 给定一个网站的访问记录, 俗称 Access log 计算其中出现的独立 IP, 以及其访问的次数 val config =
深入理解Spark RDD——RDD信息对象
beliefer的博客
08-16 3145
RDDInfo用于描述RDD的信息，RDDInfo提供的信息如下： id：RDD的id。 name：RDD的名称。 numPartitions：RDD的分区数量。 storageLevel：RDD的存储级别（即StorageLevel）。 parentIds：RDD的父亲RDD的id序列。这说明一个RDD会有零到多个父RDD。 callSite：RDD的用户调用栈信息。 scope：...
Spark RDD以及其特性.rar_RDD_Spark!_parallelbwz_spark_特性
09-21
在描述中提到的"Spark RDD以及其特性的流程图"，可能是对RDD创建、转换、持久化和执行流程的可视化表示。Visio是一款常用的流程图绘制工具，用于打开和理解这个流程图，可以帮助我们更直观地掌握RDD的工作原理。 总...
INTRO_SPARK-SCALA_FOR_STUDENTS
03-20
3. **Spark编程模型**：掌握RDD的概念，理解其容错性和转换操作。 4. **DataFrame和Spark SQL**：学习DataFrame的使用，它是Spark 2.0引入的高级API，以及如何使用Spark SQL进行结构化数据处理。 5. **Spark ...
Spark DStream相关操作
01-07
与 RDD 类似，DStream 也提供了自己的一系列操作方法，这些操作可以分成 3 类：普通的转换操作、窗口转换操作和输出操作。 普通的转换操作 普通的转换操作如表 1 所示 表 1 普通的转换操作 Suo 描述 map...
Pro_Spark_Streaming__The_Zen_of_Real
01-15
Spark Streaming支持多种窗口操作，如时间窗口和滑动窗口，这些操作对于处理时间序列数据和实现事件触发的业务逻辑至关重要。 实时数据处理的关键在于容错性和高可用性，因此，书中会详细介绍Spark Streaming如何...
【SparkCore篇08】RDD累加器和广播变量1
08-04
Spark默认提供了一种累加器类型，但如果你想实现自定义的累加器，例如支持更复杂的聚合操作，你可以继承`AccumulatorV2`类。在2.0版本之后，`AccumulatorV2`提供了更好的抽象，使得实现自定义累加器更加方便。你需要...
Spark面试题（一）
辛聪明的博客
01-02 5991
目录 一、单项选择题 二、不定项选题   三、填空题 四、判断题 五、简答题 六、编程题 一、单项选择题 1、下面哪个操作是窄依赖？（） join filter group sort RDD之间的血缘关系又称依赖，包括两种，一种是窄依赖，RDDs之间分区是一一对应的，另一种是宽依赖，下游RDD的每个分区与上游RDD(也称之为父RDD)的每个分区都有关，是多对多...
Spark基本原理，SparkRDD图解 ,Spark核心开发
czshr123的博客
09-05 253
Spark中的RDD基本操作
Mr.Phoebe的专栏
02-11 9297
Spark中的RDD基本操作 前言 RDD是spark特有的数据模型，谈到RDD就会提到什么弹性分布式数据集，什么有向无环图。这些知识点在别的地方介绍得非常多，本文就不去讲这些了。 在阅读本文时候，大家可以就把RDD当作一个数组，或者一个Scala的collection对象，这样的理解对我们学习RDD的API是非常有帮助的。 RDD的创建 Spark里的计算都是操作RDD进行，那...
spark RDD介绍
weixin_39767869的博客
01-26 2948
一、RDD介绍 RDD(Resilient Distrobuted Dataset)是spark最基本的数据结构，是分布再集群各个不同节点的不可变的数据集合。 RDD 是spark处理过程中数据的逻辑表示 RDD在spark应用的不同阶段的数据结构表示 Resilient 弹性的，可以通过RDD Lineage图（DAG）进行重新计算，具有很好的容错性 DAG在spark 程序中如何工作： (1)编译器编译好程序代码 (2)Spark创建由各个RDD组成的操作算子图，形成DAG (3)当有Action算
RDD操作详解（二）键值转换
Running_Tiger的博客
03-07 1657
RDD操作详解（二）键值转换 启动spark-shell spark-shell --master spark://node-1:7077 1. partitionBy def partitionBy(partitioner: Partitioner): RDD[(K, V)] 该函数根据partitioner函数生成新的ShuffleRDD，将原RDD重新分区。 sca...
RDD实现详解
MrGeroge的博客
12-05 653
1.RDD的三大特性 自动容错：（基于Lineage血统，即会保存创建RDD的相关转换（算子操作）） 位置感知性调度：为了尽量满足数据本地性，Task调度会依次从以下位置查找是否有计算所需的数据： 1）缓存，即待计算的数据RDD执行过cache（）操作 2）Checkpoint：即待计算的数据RDD是否执行过checkpoint（）操作，数据检查点保存 3）rdd.preferedLoc
Spark RDD 详细介绍
精益求精
09-13 1095
　　RDD(Resilent Distributed Datasets)俗称弹性分布式数据集,是Spark 底层的分布式存储的数据结构,可以说是 Spark 的核心, Spark API 的所有操作都是基于 RDD 的. 有容错机制并可以被并行操作的元素集合，具有只读、分区、容错、高效、无需物化、可以缓存、RDD依赖等特征。RDD只是数据集的抽象，分区内部并不会存储具体的数据。        R...
SparkRDD的概念和定义
china_demon的专栏
08-01 5145
1、RDD是什么        （1）为什么会产生RDD？               传统的MapReduce虽然具有自动容错、平衡负载和可拓展性的优点，但是其最大缺点是采用非循环式的数据流模型，使得在迭代计算式要进行大量的磁盘IO操作。RDD正是解决这一缺点的抽象方法        （2）RDD的具体描述RDD（弹性数据集）是Spark提供的最重要的抽象的概念，它是一种有容错机制的特
Spark 原理及RDD理解
A_Eternal的博客
08-18 672
一、spark原理图 二、sparkRDD图解 * 三、什么是Spark开发（核心编程原理） 1，定义初始的RDD，即创建最原始的RDD 2，做最初始的RDD进行算子的转换操作（flatMap，map，filter…） 3，对新形成的RDD，继续进行操作，直至结果的计算完成。 ** 四、RDD持久化原理 Spark非常重要的一个功能特性就是可以将RDD持久化在
简单描述sparkrdd和sparksql技术
最新发布
06-18
Spark RDD（Resilient Distributed Datasets）和Spark SQL是Apache Spark生态系统中的两个重要组件。 1. **Spark RDD**： Spark RDD是一个弹性分布式数据集，它是Spark的核心抽象之一。RDD代表了一种只读、分区、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值